DragonRuby Game Toolkit Live Docs

@@ -211,8 +59,8 @@ The information contained here is all available via the DragonRuby Console. You

To search docs you can type docs_search "SEARCH TERM" or if you want to get fancy you can provide a lambda to filter documentation:

docs_search { |entry| (entry.include? "Array") && (!entry.include? "Enumerable") }
-

docs_search { |entry| (entry.include? "Array") && (!entry.include? "Enumerable") }
+

@@ -262,7 +110,7 @@ You may also want to try this free course provided at https://en.wikipedia.org/wiki/Ryan_C._Gordon).

Introduction

Welcome!

@@ -278,14 +126,14 @@ Did you not know that? Did you think you couldn't write a game because you're a

Here, we're going to be programming in a language called "Ruby." In the interest of full disclosure, I (Ryan Gordon) wrote the C parts of this toolkit and Ruby looks a little strange to me (Amir Rajan wrote the Ruby parts, discounting the parts I mangled), but I'm going to walk you through the basics because we're all learning together, and if you mostly think of yourself as someone that writes C (or C++, C#, Objective-C), PHP, or Java, then you're only a step behind me right now.

Prerequisites

Here's the most important thing you should know: Ruby lets you do some complicated things really easily, and you can learn that stuff later. I'm going to show you one or two cool tricks, but that's all.

Do you know what an if statement is? A for-loop? An array? That's all you'll need to start.

The Game Loop

Ok, here are few rules with regards to game development with GTK:

@@ -300,18 +148,18 @@ That's an entire video game in one run-on sentence.

Here's that function. You're going to want to put this in mygame/app/main.rb, because that's where we'll look for it by default. Load it up in your favorite text editor.

def tick args
+def tick args
   args.outputs.labels << [580, 400, 'Hello World!']
 end
-

+

Now run dragonruby ...did you get a window with "Hello World!" written in it? Good, you're officially a game developer!

Breakdown Of The `tick` Method

mygame/app/main.rb, is where the Ruby source code is located. This looks a little strange, so I'll break it down line by line. In Ruby, a '#' character starts a single-line comment, so I'll talk about this inline.

# This "def"ines a function, named "tick," which takes a single argument
+# This "def"ines a function, named "tick," which takes a single argument
 # named "args". DragonRuby looks for this function and calls it every
 # frame, 60 times a second. "args" is a magic structure with lots of
 # information in it. You can set variables in there for your own game state,
@@ -328,11 +176,11 @@ def tick args
   # args.outputs.labels)
   args.outputs.labels << [580, 400, 'Hello World!']
 end
-

+

Once your tick function finishes, we look at all the arrays you made and figure out how to draw it. You don't need to know about graphics APIs. You're just setting up some arrays! DragonRuby clears out these arrays every frame, so you just need to add what you need _right now_ each time.

Rendering A Sprite

Now let's spice this up a little.

@@ -342,18 +190,18 @@ We're going to add some graphics. Each 2D image in DragonRuby is called a "sprit

There's a "dragonruby.png" file included, just to get you started. Let's have it draw every frame with our text:

def tick args
+def tick args
   args.outputs.labels  << [580, 400, 'Hello World!']
   args.outputs.sprites << [576, 100, 128, 101, 'dragonruby.png']
 end
-

+

(Pro Tip: you don't have to restart DragonRuby to test your changes; when you save main.rb, DragonRuby will notice and reload your program.)

That .sprites line says "add a sprite to the list of sprites we're drawing, and draw it at position (576, 100) at a size of 128x101 pixels". You can find the image to draw at dragonruby.png.

Coordinate System and Virtual Canvas

Quick note about coordinates: (0, 0) is the bottom left corner of the screen, and positive numbers go up and to the right. This is more "geometrically correct," even if it's not how you remember doing 2D graphics, but we chose this for a simpler reason: when you're making Super Mario Brothers and you want Mario to jump, you should be able to add to Mario's y position as he goes up and subtract as he falls. It makes things easier to understand.

@@ -363,17 +211,17 @@ Also: your game screen is _always_ 1280x720 pixels. If you resize the window, we

Ok, now we have an image on the screen, let's animate it:

def tick args
+def tick args
   args.state.rotation  ||= 0
   args.outputs.labels  << [580, 400, 'Hello World!' ]
   args.outputs.sprites << [576, 100, 128, 101, 'dragonruby.png', args.state.rotation]
   args.state.rotation  -= 1
 end
-

+

Now you can see that this function is getting called a lot!

Game State

Here's a fun Ruby thing: args.state.rotation ||= 0 is shorthand for "if args.state.rotation isn't initialized, set it to zero." It's a nice way to embed your initialization code right next to where you need the variable.

@@ -383,18 +231,18 @@ Here's a fun Ruby thing: args.state.rotation ||= 0 is shorthand for

In this case, the current rotation of our sprite, which is happily spinning at 60 frames per second. If you don't specify rotation (or alpha, or color modulation, or a source rectangle, etc), DragonRuby picks a reasonable default, and the array is ordered by the most likely things you need to tell us: position, size, name.

There Is No Delta Time

One thing we decided to do in DragonRuby is not make you worry about delta time: your function runs at 60 frames per second (about 16 milliseconds) and that's that. Having to worry about framerate is something massive triple-AAA games do, but for fun little 2D games? You'd have to work really hard to not hit 60fps. All your drawing is happening on a GPU designed to run Fortnite quickly; it can definitely handle this.

Since we didn't make you worry about delta time, you can just move the rotation by 1 every time and it works without you having to keep track of time and math. Want it to move faster? Subtract 2.

Handling User Input

Now, let's move that image around.

def tick args
+def tick args
   args.state.rotation ||= 0
   args.state.x ||= 576
   args.state.y ||= 100
@@ -414,11 +262,11 @@ Now, let's move that image around.
 
   args.state.rotation -= 1
 end
-

+

Everywhere you click your mouse, the image moves there. We set a default location for it with args.state.x ||= 576, and then we change those variables when we see the mouse button in action. You can get at the keyboard and game controllers in similar ways.

Coding On A Raspberry Pi

We have only tested DragonRuby on a Raspberry Pi 3, Models B and B+, but we believe it _should_ work on any model with comparable specs.

@@ -428,8 +276,8 @@ If you're running DragonRuby Game Toolkit on a Raspberry Pi, or trying to run a

You're probably running a desktop environment: menus, apps, web browsers, etc. This is okay! Launch the terminal app and type:

do raspi-config
-

do raspi-config
+

It'll ask you for your password (if you don't know, try "raspberry"), and then give you a menu of options. Find your way to "Advanced Options", then "GL Driver", and change this to "GL (Full KMS)" ... not "fake KMS," which is also listed there. Save and reboot. In theory, this should fix the problem.

@@ -439,51 +287,15 @@ If you're _still_ having problems and have a Raspberry Pi 2 or better, go back t

Note that you can also run DragonRuby without X11 at all: if you run it from a virtual terminal it will render fullscreen and won't need the "Full KMS" option. This might be attractive if you want to use it as a game console sort of thing, or develop over ssh, or launch it from RetroPie, etc.

Conclusion

There is a lot more you can do with DragonRuby, but now you've already got just about everything you need to make a simple game. After all, even the most fancy games are just creating objects and moving them around. Experiment a little. Add a few more things and have them interact in small ways. Want something to go away? Just don't add it to args.output anymore.

IMPORTANT: Go through all of the sample apps! Study them thoroughly!! No really, you should definitely do this!

-Now that you've completed the Hello World tutorial. Head over to the `samples` directory. It is very very important that you study the sample apps thoroughly! Go through them in order. Here is a short description of each sample app. -

Guided Samples

samples/00_learn_ruby_optional: This directory contains sample apps that will help you learn the language.
samples/01_rendering_basics: This set of samples will show you how to render basic primitives such as labels, solids, borders, lines, sprites, and how to play sounds.
samples/02_input_basics: This set of samples show you how to accept input from the mouse, keyboard, and controllers.
samples/03_rendering_sprites: This set of samples shows you all the different ways to render sprites (including how to use a sprite sheet).
samples/04_physics_and_collision: This set of samples shows how to do various types of collisions and physics.
samples/05_mouse: This set of samples show more advanced usages of the mouse.
samples/06_save_load: This set of samples show how to save and load game data.
samples/07_advanced_rendering: This set of samples show how to programmatically render sprites using render targets.
samples/08_tweening_lerping_easing_functions: This set of samples show how to perform animations.
samples/09_performance: This set of samples show how to handle performance issues when a large number of sprites on the screen.
samples/10_advanced_debugging: This set of samples show how advanced debugging techniques and testing techniques.
samples/11_http: This set of samples show how use http.

Sample Games

-There are samples that contain the path samples/99_*. The sample apps that are prefixed with 99_ show non-trivial implemementations for a real game: -

3D Cube: Shows how to do faux 3D in DragonRuby.
Dueling Starships: A two player top-down versus game where each player controls a ship.
Flappy Dragon: DragonRuby's clone of Flappy Bird.
Pong: A simple implementation of the game Pong.
Snakemoji: The classic game of Snake but with all of the code written using emojis (sometimes you just have to have a little fun).
Solar System: A simulation of our solar system.
Crafting Starting Point: A starting point for those that want to build a crafting game.
Dev Tools: A set of sample apps that show how you can extend DragonRuby's Console, starting point for a tile editor, and a starting point for a paint app.
LOWREZ: Sample apps that show how to render at different resolutions.
RPG: Various sample apps that show how to create narrative, topdown, tactical grid-based, and roguelike RPGs.
Platformers: Various sample apps that show how to create different kinds of physics/collision based platformers.

Deploying To Itch.io

Once you've built your game, you're all set to deploy! Good luck in your game dev journey and if you get stuck, come to the Discord channel!

Creating Your Game Landing Page

Log into Itch.io and go to https://itch.io/game/new.

@@ -498,28 +310,28 @@ Log into Itch.io and go to https://itch.io/ga

You can fill out all the other options later.

Update Your Game's Metadata

Point your text editor at mygame/metadata/game_metadata.txt and make it look like this:

NOTE: Remove the # at the beginning of each line.

devid=bob
+devid=bob
 devtitle=Bob The Game Developer
 gameid=mygame
 gametitle=My Game
 version=0.1
-

+

The devid property is the username you use to log into Itch.io. The devtitle is your name or company name (it can contain spaces). The gameid is the Project URL value. The gametitle is the name of your game (it can contain spaces). The version can be any major.minor number format.

Building Your Game For Distribution

Open up the terminal and run this from the command line:

./dragonruby-publish --only-package mygame
-

./dragonruby-publish --only-package mygame
+

(if you're on Windows, don't put the "./" on the front. That's a Mac and Linux thing.)

@@ -532,8 +344,8 @@ For the HTML version of your game after you upload it. Check the checkbox labele

For subsequent updates you can use an automated deployment to Itch.io:

./dragonruby-publish mygame
-

./dragonruby-publish mygame
+

DragonRuby will package _and publish_ your game to itch.io! Tell your friends to go to your game's very own webpage and buy it!

@@ -550,16 +362,16 @@ To deploy to iOS, you need to have a Mac running MacOS Catalina, an iOS device,

To deploy to Android, you need to have an Android emulator/device, and a environment that is able to run Android SDK. dragonruby-publish will create an APK for you. From there, you can sign the APK and install it to your device. The signing and installation procedure varies from OS to OS. Here's an example of what the command might look like:

> adb logcat -e mygame # you'll want to run this in a separate terminal
+> adb logcat -e mygame # you'll want to run this in a separate terminal
 > keytool -genkey -v -keystore mygame.keystore -alias mygame -keyalg RSA -keysize 2048 -validity 10000
 > apksigner sign --ks mygame.keystore mygame-android.apk
 > adb install mygame-android.apk
-

+

DragonRuby's Philosophy

The following tenants of DragonRuby are what set us apart from other game engines. Given that Game Toolkit is a relatively new engine, there are definitely features that are missing. So having a big check list of "all the cool things" is not this engine's forte. This is compensated with a strong commitment to the following principals.

Challenge The Status Quo

Game engines of today are in a local maximum and don't take into consideration the challenges of this day and age. Unity and GameMaker specifically rot your brain. It's not sufficient to say:

@@ -571,51 +383,49 @@ But that's how we've always done it.

It's a hard pill to swallow, but forget blindly accepted best practices and try to figure out the underlying motivation for a specific approach to game development. Collaborate with us.

Continuity of Design

-There is a programming idiom in software called "the pit of success". The term normalizes up front pain as a necessity in the (hopes that the investment will yield dividends "when you become successful"). This results in more "Enterprise TM" code upfront, and makes it more difficult to get started when you are new to programming. +There is a programming idiom in software called "The Pit of Success". The term normalizes upfront pain as a necessity/requirement in the hopes that the investment will yield dividends "when you become successful" or "when the code becomes more complicated". This approach to development is strongly discouraged by us. It leads to over-architected and unnecessary code; creates barriers to rapid prototyping and shipping a game; and overwhelms beginners who are new to the engine or programming in general.

-DragonRuby's philosophy is to provide a spectrum across the "make it fast" vs "make it right" spectrum and provide incremental, intuitive transitions between points on that spectrum. This is captured in how render primitives can be represented as tuples/arrays, hashes, open structs/entities, and then finally classes (as opposed to forcing devs to use classes upfront). +DragonRuby's philosophy is to provide multiple options across the "make it fast" vs "make it right" spectrum, with incremental/intuitive transitions between the options provided. A concrete example of this philosophy would be render primitives: the spectrum of options allows renderable constructs take the form of tuples/arrays (easy to pickup, simple, and fast to code/prototype with), hashes (a little more work, but gives you the ability to add additional properties), open and string entities (more work than hashes, but yields cleaner apis), and finally - if you really need full power/flexibility in rendering - classes (which take the most amount of code and programming knowledge to create).

Release Often And Soon

Release Early and Often

-The biggest mistake game devs make is spending too much time in isolation building their game. Release something, however small, and release it quickly. +The biggest mistake game devs make is spending too much time in isolation building their game. Release something, however small, and release it soon.

Stop worrying about everything being pixel perfect. Don't wait until your game is 100% complete. Build your game publicly and iterate. Post in the #show-and-tell channel in the community Discord. You'll find a lot of support and encouragement there.

-Remember: +Real artists ship. Remember that.

-
-Real artists ship. -
-

Sustainable And Ethical Monetization

We all aspire to put food on the table doing what we love. Whether it is building games, writing tools to support game development, or anything in between.

Charge a fair amount of money for the things you create. It's expected and encouraged within the community. Give what you create away for free to those that can't afford it.

Sustainable And Ethical Open Source

+If you are gainfully employed, pay full price for the things you use. If you do end up getting something at a discount, pay the difference "forward" to someone else. +

Sustainable And Ethical Open Source

This goes hand in hand with sustainable and ethical monetization. The current state of open source is not sustainable. There is an immense amount of contributor burnout. Users of open source expect everything to be free, and few give back. This is a problem we want to fix (we're still trying to figure out the best solution).

So, don't be "that guy" in the Discord that says "DragonRuby should be free and open source!" You will be personally flogged by Amir.

People Over Entities

We prioritize the endorsement of real people over faceless entities. This game engine, and other products we create, are not insignificant line items of a large company. And you aren't a generic "commodity" or "corporate resource". So be active in the community Discord and you'll reap the benefits as more devs use DragonRuby.

Building A Game Should Be Fun And Bring Happiness

We will prioritize the removal of pain. The aesthetics of Ruby make it such a joy to work with, and we want to capture that within the engine.

Real World Application Drives Features

We are bombarded by marketing speak day in and day out. We don't do that here. There are things that are really great in the engine, and things that need a lot of work. Collaborate with us so we can help you reach your goals. Ask for features you actually need as opposed to anything speculative.

@@ -626,8 +436,8 @@ We want DragonRuby to *actually* help you build the game you want to build (as o

Here are questions, comments, and concerns that frequently come up.

Frequently Asked Questions

What is DragonRuby LLP?

Frequently Asked Questions

What is DragonRuby LLP?

DragonRuby LLP is a partnership of four devs who came together with the goal of bringing the aesthetics and joy of Ruby, everywhere possible.

@@ -652,7 +462,7 @@ NOTE: We leave the "A DragonRuby LLP Product" off of this one because that just

NOTE: Devs who use DragonRuby are "Dragon Riders/Riders of Dragons". That's a bad ass identifier huh?

What is DragonRuby?

The response to this question requires a few subparts. First we need to clarify some terms. Specifically _language specification_ vs _runtime_.

@@ -703,7 +513,7 @@ These levels allow us to stay up to date with open source implementations of Rub

DragonRuby is a Ruby runtime implementation that takes all the lessons we've learned from MRI/CRuby, and merges it with the latest and greatest compiler and OSS technologies.

How is DragonRuby different than MRI?

DragonRuby supports a subset of MRI apis. Our target is to support all of mRuby's standard lib. There are challenges to this given the number of platforms we are trying to support (specifically console).

@@ -718,11 +528,11 @@ You can use DragonRuby's Console within the game to inspect object and execute s

Any code you write in there will be executed when you change the file. You can organize different pieces of code using the repl method:

repl do
+repl do
   puts "hello world"
   puts 1 + 1
 end
-

+

If you use the `repl` method, the code will be executed and the DragonRuby Console will automatically open so you can see the results (on Mac and Linux, the results will also be printed to the terminal).

All puts statements will also be saved to logs/log.txt. So if you want to stay in your editor and not look at the terminal, or the DragonRuby Console, you can tail this file.

@@ -730,7 +540,7 @@ end

4. To ignore code in repl.rb, instead of commenting it out, prefix repl with the letter x and it'll be ignored.

xrepl do # <------- line is prefixed with an "x"
+xrepl do # <------- line is prefixed with an "x"
   puts "hello world"
   puts 1 + 1
 end
@@ -746,9 +556,9 @@ end
 
 # use xrepl to "comment out" code
 xrepl do
-  puts "This code will not be executed because of the x infront of repl".
+  puts "This code will not be executed because of the x in front of repl".
 end
-

+

Does DragonRuby support `pry` or have any other debugging facilities?

pry is a gem that assumes you are using the MRI Runtime (which is incompatible with DragonRuby). Eventually DragonRuby will have a pry based experience that is compatible with a debugging infrastructure called LLDB. Take the time to read about LLDB as it shows the challenges in creating something that is compatible. @@ -763,8 +573,8 @@ You can use DragonRuby's replay capabilities to troubleshoot:

Get into the habit of adding debugging facilities within the game itself. You can add drawing primitives to args.outputs.debug that will render on top of your game but will be ignored in a production release.

Debugging something that runs at 60fps is (imo) not that helpful. The exception you are seeing could have been because of a change that occurred many frames ago.

Frequent Comments About Ruby as a Language Choice

But Ruby is dead.

Frequent Comments About Ruby as a Language Choice

But Ruby is dead.

Let's check the official source for the answer to this question: isrubydead.com: https://isrubydead.com/.

Let's stop making this comment shall we?

But Ruby is slow.

That doesn't make any sense. A language specification can't be slow... it's a language spec. Sure, an _implementation/runtime_ can be slow though, but then we'd have to talk about which runtime.

Dynamic languages are slow.

They are certainly slower than statically compiled languages. With the processing power and compiler optimizations we have today, dynamic languages like Ruby are _fast enough_.

NOTE: If you _are_ hand writing LLVM IR, we are always open to bringing on new partners with such a skill set. Email us ^_^.

Frequent Concerns

DragonRuby is not open source. That's not right.

Frequent Concerns

DragonRuby is not open source. That's not right.

The current state of open source is unsustainable. Contributors work for free, most all open source repositories are severely under-staffed, and burnout from core members is rampant.

All this being said, we do have parts of the engine open sourced on GitHub: https://github.com/dragonruby/dragonruby-game-toolkit-contrib/

DragonRuby is for pay. You should offer a free version.

If you can afford to pay for DragonRuby, you should (and will). We don't go around telling writers that they should give us their books for free, and only require payment if we read the entire thing. It's time we stop asking that of software products.

Just contact Amir at amir.rajan@dragonruby.org with a short explanation of your current situation and he'll set you up. No questions asked.

But still, you should offer a free version. So I can try it out and see if I like it.

You can try our [web-based sandbox environment](). But it won't do the runtime justice. Or just come to our [Slack]() or [Discord]() channel and ask questions. We'd be happy to have a one on one video chat with you and show off all the cool stuff we're doing.

Seriously just buy it. Get a refund if you don't like it. We make it stupid easy to do so.

I still think you should do a free version. Think of all people who would give it a shot.

Free isn't a sustainable financial model. We don't want to spam your email. We don't want to collect usage data off of you either. We just want to provide quality toolchains to quality developers (as opposed to a large quantity of developers).

The people that pay for DragonRuby and make an effort to understand it are the ones we want to build a community around, partner with, and collaborate with. So having that small monetary wall deters entitled individuals that don't value the same things we do.

What if I build something with DragonRuby, but DragonRuby LLP becomes insolvent.

That won't happen if the development world stop asking for free stuff and non-trivially compensate open source developers. Look, we want to be able to work on the stuff we love, every day of our lives. And we'll go to great lengths to make that happen.

But, in the event that sad day comes, our partnership bylaws state that _all_ DragonRuby IP that can be legally open sourced, will be released under a permissive license.

CHEATSHEET: How To Determine What Frame You Are On

RECIPIES:

How To Determine What Frame You Are On

There is a property on state called tick_count that is incremented by DragonRuby every time the tick method is called. The following code renders a label that displays the current tick_count.

def tick args
+def tick args
   args.outputs.labels << [10, 670, "#{args.state.tick_count}"]
 end
-

-CHEATSHEET: How To Get Current Framerate
+

How To Get Current Framerate

Current framerate is a top level property on the Game Toolkit Runtime and is accessible via args.gtk.current_framerate.

def tick args
+def tick args
   args.outputs.labels << [10, 710, "framerate: #{args.gtk.current_framerate.round}"]
 end
-

-CHEATSHEET: How To Render A Sprite Using An Array
+

How To Render A Sprite Using An Array

All file paths should use the forward slash / *not* backslash . Game Toolkit includes a number of sprites in the sprites folder (everything about your game is located in the mygame directory).

width

height
 args.outputs.sprites is used to render a sprite.
 
-def tick args
+def tick args
   args.outputs.sprites << [
     640 - 50,                 # X
     360 - 50,                 # Y
@@ -886,12 +697,12 @@ The following code renders a sprite with a width and height
-CHEATSHEET: More Sprite Properties As An Array
+

+More Sprite Properties As An Array
 
 Here are all the properties you can set on a sprite.
 
-def tick args
+def tick args
   args.outputs.sprites << [
     100,                       # X
     100,                       # Y
@@ -905,15 +716,15 @@ Here are all the properties you can set on a sprite.
     0                          # BLUE_SATURATION
   ]
 end
-

-CHEATSHEET: Different Sprite Representations
+
+Different Sprite Representations
 
 Using ordinal positioning can get a little unruly given so many properties you have control over.
 
 
 You can represent a sprite as a Hash:
 
-def tick args
+def tick args
   args.outputs.sprites << {
     x: 640 - 50,
     y: 360 - 50,
@@ -935,11 +746,11 @@ You can represent a sprite as a Hash:
     angle_anchor_y: 1.0
   }
 end
-

+
 
 You can represent a sprite as an object:
 
-# Create type with ALL sprite properties AND primitive_marker
+# Create type with ALL sprite properties AND primitive_marker
 class Sprite
   attr_accessor :x, :y, :w, :h, :path, :angle, :a, :r, :g, :b,
                 :source_x, :source_y, :source_w, :source_h,
@@ -968,8 +779,8 @@ def tick args
                                           w: 50,
                                           h: 50)
 end
-

-CHEATSHEET: How To Render A Label
+
+How To Render A Label
 
 args.outputs.labels is used to render labels.
 
@@ -979,20 +790,20 @@ Labels are how you display text. This code will go directly inside of the 
 
 Here is the minimum code:
 
-def tick args
+def tick args
   #                       X    Y    TEXT
   args.outputs.labels << [640, 360, "I am a black label."]
 end
-

-CHEATSHEET: A Colored Label
-def tick args
+
+A Colored Label
+def tick args
   # A colored label
   #                       X    Y    TEXT,                   RED    GREEN  BLUE  ALPHA
   args.outputs.labels << [640, 360, "I am a redish label.", 255,     128,  128,   255]
 end
-

-CHEATSHEET: Extended Label Properties
-def tick args
+
+Extended Label Properties
+def tick args
   # A colored label
   #                       X    Y     TEXT           SIZE  ALIGNMENT  RED  GREEN  BLUE  ALPHA  FONT FILE
   args.outputs.labels << [
@@ -1008,18 +819,18 @@ end
     "fonts/coolfont.ttf"   # FONT
   ]
 end
-

+
 
 A SIZE_ENUM of 0 represents "default size". A negative value will decrease the label size. A positive value will increase the label's size.
 
 
 An ALIGNMENT_ENUM of 0 represents "left aligned". 1 represents "center aligned". 2 represents "right aligned".
 
-CHEATSHEET: Rendering A Label As A Hash
+Rendering A Label As A Hash
 
 You can add additional metadata about your game within a label, which requires you to use a `Hash` instead.
 
-def tick args
+def tick args
   args.outputs.labels << {
     x:              200,
     y:              550,
@@ -1040,12 +851,12 @@ You can add additional metadata about your game within a label, which requires y
     }
   }
 end
-

-CHEATSHEET: Getting The Size Of A Piece Of Text
+
+Getting The Size Of A Piece Of Text
 
 You can get the render size of any string using args.gtk.calcstringbox.
 
-def tick args
+def tick args
   #                             TEXT           SIZE_ENUM  FONT
   w, h = args.gtk.calcstringbox("some string",         0, "font.ttf")
 
@@ -1059,39 +870,39 @@ You can get the render size of any string using args.gtk.calcstringbox
-CHEATSHEET: How To Play A Sound
+

+How To Play A Sound
 
 Sounds that end .wav will play once:
 
-def tick args
+def tick args
   # Play a sound every second
   if (args.state.tick_count % 60) == 0
     args.outputs.sounds << 'something.wav'
   end
 end
-

+
 
 Sounds that end .ogg is considered background music and will loop:
 
-def tick args
+def tick args
   # Start a sound loop at the beginning of the game
   if args.state.tick_count == 0
     args.outputs.sounds << 'background_music.ogg'
   end
 end
-

+
 
 If you want to play a .ogg once as if it were a sound effect, you can do:
 
-def tick args
+def tick args
   # Play a sound every second
   if (args.state.tick_count % 60) == 0
     args.gtk.queue_sound 'some-ogg.ogg'
   end
 end
-

-CHEATSHEET: Using args.state To Store Your Game State
+
+Using args.state To Store Your Game State
 
 args.state is a open data structure that allows you to define properties that are arbitrarily nested. You don't need to define any kind of class.
 
@@ -1101,7 +912,7 @@ To initialize your game state, use the ||= operator. Any value on t
 
 To assign a value every frame, just use the = operator, but _make sure_ you've initialized a default value.
 
-def tick args
+def tick args
   # initialize your game state ONCE
   args.state.player.x  ||= 0
   args.state.player.y  ||= 0
@@ -1124,25 +935,25 @@ To assign a value every frame, just use the = operator, but _make s
     args.state.player.hp
   ]
 end
-

-CHEATSHEET: Troubleshoot Performance
+
+Troubleshoot Performance
 
  If you're using Arrays for your primitives (args.outputs.sprites << []), use Hash instead (args.outputs.sprites << { x: ... }).
  If you're using Entity for your primitives (args.outputs.sprites << args.state.new_entity), use StrictEntity instead (args.outputs.sprites << args.state.new_entity_strict).
  Use .each instead of .map if you don't care about the return value.
  When concatenating primitives to outputs, do them in bulk. Instead of:
 
-args.state.bullets.each do |bullet|
+args.state.bullets.each do |bullet|
   args.outputs.sprites << bullet.sprite
 end
-

+
 
 do
 
-args.outputs.sprites << args.state.bullets.map do |b|
+args.outputs.sprites << args.state.bullets.map do |b|
   b.sprite
 end
-

+
 
 5. Use args.outputs.static_ variant for things that don't change often (take a look at the Basic Gorillas sample app and Dueling Starships sample app to see how static_ is leveraged.
 
@@ -1153,1965 +964,10609 @@ end
 
 The GTK::Runtime class is the core of DragonRuby. It is globally accessible via $gtk.
 
-DOCS: GTK::Runtime#write_file
+SUMMARY: def tick args; end;
 
-This function takes in two parameters. The first paramter is the file path and assumes the the game directory is the root. The second parameter is the string that will be written. The method overwrites whatever is currently in the file. Use GTK::Runtime#append_file to append to the file as opposed to overwriting.
+Most everything you will need to build your game is in the args parameter that is provided to your tick method. Follows is a high level summary of each function that is available from args.
 
-def tick args
-  if args.inputs.mouse.click
-    args.gtk.write_file "last-mouse-click.txt", "Mouse was clicked at #{args.state.tick_count}."
-  end
-end
-
-DOCS: GTK::Runtime#reset
 
-This function will reset Kernel.tick_count to 0 and will remove all data from args.state.
+All the properties below hang off of args and can be accessed in the tick method:
 
-DOCS: GTK::Runtime#calcstringbox
+def tick args
+  args.PROPERTY
+end
+
+args.state
 
-This function returns the width and height of a string.
+Store your game state inside of this state. Properties with arbitrary nesting is allowed and a backing Entity will be created on your behalf.
 
-def tick args
-  args.state.string_size           ||= args.gtk.calcstringbox "Hello World"
-  args.state.string_size_font_size ||= args.gtk.calcstringbox "Hello World"
+def tick args
+  args.state.player.x ||= 0
+  args.state.player.y ||= 0
 end
-

-DOCS: Array
+
+.*.entity_id
 
-The Array class has been extend to provide methods that will help in common game development tasks. Array is one of the most powerful classes in Ruby and a very fundamental component of Game Toolkit.
+Entities automatically receive an entity_id of type Fixnum.
 
-DOCS: Array#map
+.*.entity_type
 
-The function given a block returns a new Enumerable of values.
+Entities can have an entity_type which is represented as a Symbol.
 
+.*.created_at
 
-Example of using Array#map in conjunction with args.state and args.outputs.sprites to render sprites to the screen.
+Entities have created_at set to args.state.tick_count when they are created.
 
-def tick args
-  # define the colors of the rainbow in ~args.state~
-  # as an ~Array~ of ~Hash~es with :order and :name.
-  # :order will be used to determine render location
-  #  and :name will be used to determine sprite path.
-  args.state.rainbow_colors ||= [
-    { order: 0, name: :red    },
-    { order: 1, name: :orange },
-    { order: 2, name: :yellow },
-    { order: 3, name: :green  },
-    { order: 4, name: :blue   },
-    { order: 5, name: :indigo },
-    { order: 6, name: :violet },
-  ]
-
-  # render sprites diagonally to the screen
-  # with a width and height of 50.
-  args.outputs
-      .sprites << args.state
-                      .rainbow_colors
-                      .map do |color| # <-- ~Array#map~ usage
-                        [
-                          color[:order] * 50,
-                          color[:order] * 50,
-                          50,
-                          50,
-                          "sprites/square-#{color[:name]}.png"
-                        ]
-                      end
-end
-
-DOCS: Array#each
+.*.created_at_elapsed
 
-The function, given a block, invokes the block for each item in the Array. Array#each is synonymous to foreach constructs in other languages.
+Returns the elapsed number of ticks since creation.
 
+.*.global_created_at
 
-Example of using Array#each in conjunction with args.state and args.outputs.sprites to render sprites to the screen:
+Entities have global_created_at set to Kernel.global_tick_count when they are created.
 
-def tick args
-  # define the colors of the rainbow in ~args.state~
-  # as an ~Array~ of ~Hash~es with :order and :name.
-  # :order will be used to determine render location
-  #  and :name will be used to determine sprite path.
-  args.state.rainbow_colors ||= [
-    { order: 0, name: :red    },
-    { order: 1, name: :orange },
-    { order: 2, name: :yellow },
-    { order: 3, name: :green  },
-    { order: 4, name: :blue   },
-    { order: 5, name: :indigo },
-    { order: 6, name: :violet },
-  ]
-
-  # render sprites diagonally to the screen
-  # with a width and height of 50.
-  args.state
-      .rainbow_colors
-      .map do |color| # <-- ~Array#each~ usage
-        args.outputs.sprites << [
-          color[:order] * 50,
-          color[:order] * 50,
-          50,
-          50,
-          "sprites/square-#{color[:name]}.png"
-        ]
-      end
-end
-
-DOCS: Array#reject_nil
+.*.global_created_at_elapsed
 
-Returns an Enumerable rejecting items that are nil, this is an alias for Array#compact:
+Returns the elapsed number of global ticks since creation.
 
-repl do
-  a = [1, nil, 4, false, :a]
-  puts a.reject_nil
-  # => [1, 4, false, :a]
-  puts a.compact
-  # => [1, 4, false, :a]
-end
-
-DOCS: Array#reject_false
+.*.as_hash
 
-Returns an `Enumerable` rejecting items that are `nil` or `false`.
+Entity cast to a Hash so you can update values as if you were updating a Hash.
 
-repl do
-  a = [1, nil, 4, false, :a]
-  puts a.reject_false
-  # => [1, 4, :a]
+.new_entity
+
+Creates a new Entity with a type, and initial properties. An option block can be passed to change the newly created entity:
+
+def tick args
+  args.state.player ||= args.state.new_entity :player, x: 0, y: 0 do |e|
+    e.max_hp = 100
+    e.hp     = e.max_hp * rand
+  end
 end
-

-DOCS: Array#product
+
+.new_entity_strict
 
-Returns all combinations of values between two arrays.
+Creates a new Strict Entity. While Entities created via args.state.new_entity can have new properties added later on, Entities created using args.state.new_entity must define all properties that are allowed during its initialization. Attempting to add new properties after initialization will result in an exception.
 
+.tick_count
 
-Here are some examples of using product. Paste the following code at the bottom of main.rb and save the file to see the results:
+Returns the current tick of the game. args.state.tick_count is 0 when the game is first started or if the game is reset via $gtk.reset.
 
-repl do
-  a = [0, 1]
-  puts a.product
-  # => [[0, 0], [0, 1], [1, 0], [1, 1]]
-end
-
-repl do
-  a = [ 0,  1]
-  b = [:a, :b]
-  puts a.product b
-  # => [[0, :a], [0, :b], [1, :a], [1, :b]]
-end
-
-DOCS: Array#map_2d
+args.inputs
 
-Assuming the array is an array of arrays, Given a block, each 2D array index invoked against the block. A 2D array is a common way to store data/layout for a stage.
+Access using input using args.inputs.
 
-repl do
-  stage = [
-    [:enemy, :empty, :player],
-    [:empty, :empty,  :empty],
-    [:enemy, :empty,  :enemy],
-  ]
-
-  occupied_tiles = stage.map_2d do |row, col, tile|
-    if tile == :empty
-      nil
-    else
-      [row, col, tile]
-    end
-  end.reject_nil
-
-  puts "Stage:"
-  puts stage
-
-  puts "Occupied Tiles"
-  puts occupied_tiles
-end
-
-DOCS: Array#include_any?
+.up
 
-Given a collection of items, the function will return true if any of self's items exists in the collection of items passed in:
+Returns true if: the up arrow or w key is pressed or held on the keyboard; or if up is pressed or held on controller_one; or if the left_analog on controller_one is tilted upwards.
 
-DOCS: Array#any_intersect_rect?
+.down
 
-Assuming the array contains objects that respond to left, right, top, bottom, this method returns true if any of the elements within the array intersect the object being passed in. You are given an optional parameter called tolerance which informs how close to the other rectangles the elements need to be for it to be considered intersecting.
+Returns true if: the down arrow or s key is pressed or held on the keyboard; or if down is pressed or held on controller_one; or if the left_analog on controller_one is tilted downwards.
 
+.left
 
-The default tolerance is set to 0.1, which means that the primitives are not considered intersecting unless they are overlapping by more than 0.1.
+Returns true if: the left arrow or a key is pressed or held on the keyboard; or if left is pressed or held on controller_one; or if the left_analog on controller_one is tilted to the left.
 
-repl do
-  # Here is a player class that has position and implement
-  # the ~attr_rect~ contract.
-  class Player
-    attr_rect
-    attr_accessor :x, :y, :w, :h
-
-    def initialize x, y, w, h
-      @x = x
-      @y = y
-      @w = w
-      @h = h
-    end
-
-    def serialize
-      { x: @x, y: @y, w: @w, h: @h }
-    end
-
-    def inspect
-      "#{serialize}"
-    end
-
-    def to_s
-      "#{serialize}"
-    end
-  end
-
-  # Here is a definition of two walls.
-  walls = [
-     [10, 10, 10, 10],
-     { x: 20, y: 20, w: 10, h: 10 },
-   ]
-
-  # Display the walls.
-  puts "Walls."
-  puts walls
-  puts ""
-
-  # Check any_intersect_rect? on player
-  player = Player.new 30, 20, 10, 10
-  puts "Is Player #{player} touching wall?"
-  puts (walls.any_intersect_rect? player)
-  # => false
-  # The value is false because of the default tolerance is 0.1.
-  # The overlap of the player rect and any of the wall rects is
-  # less than 0.1 (for those that intersect).
-  puts ""
-
-  player = Player.new 9, 10, 10, 10
-  puts "Is Player #{player} touching wall?"
-  puts (walls.any_intersect_rect? player)
-  # => true
-  puts ""
-end
-
-DOCS: GTK::Outputs
+.right
 
-Outputs is how you render primitives to the screen. The minimal setup for rendering something to the screen is via a tick method defined in mygame/app/main.rb
+Returns true if: the right arrow or d key is pressed or held on the keyboard; or if right is pressed or held on controller_one; or if the left_analog on controller_one is tilted to the right.
 
-def tick args
-  # code goes here
-end
-
-DOCS: GTK::Outputs#solids
+.left_right
 
-Add primitives to this collection to render a solid to the screen.
+Returns -1 (left), 0 (neutral), or +1 (right) depending on results of args.inputs.left and args.inputs.right.
 
-Rendering a solid using an Array
+.up_down
 
-Creates a solid black rectangle located at 100, 100. 160 pixels wide and 90 pixels tall.
+Returns -1 (down), 0 (neutral), or +1 (right) depending on results of args.inputs.up and args.inputs.down.
 
-def tick args
-  #                         X    Y  WIDTH  HEIGHT
-  args.outputs.solids << [100, 100,   160,     90]
-end
-
-Rendering a solid using an Array with colors and alpha
+.text OR .history
 
-The value for the color and alpha is an number between 0 and 255. The alpha property is optional and will be set to 255 if not specified.
+Returns a string that represents the last key that was pressed on the keyboard.
 
+.mouse
 
-Creates a green solid rectangle with an opacity of 50%.
+Represents the user's
 
-def tick args
-  #                         X    Y  WIDTH  HEIGHT  RED  GREEN  BLUE  ALPHA
-  args.outputs.solids << [100, 100,   160,     90,   0,   255,    0,   128]
-end
-
-Rendering a solid using a Hash
+.x
 
-If you want a more readable invocation. You can use the following hash to create a solid. Any parameters that are not specified will be given a default value. The keys of the hash can be provided in any order.
+Returns the current x location of the mouse.
 
-def tick args
-  args.outputs.solids << {
-    x:    0,
-    y:    0,
-    w:  100,
-    h:  100,
-    r:    0,
-    g:  255,
-    b:    0,
-    a:  255
-  }
-end
-
-Rendering a solid using a Class
+mouse.y
 
-You can also create a class with solid/border properties and render it as a primitive. ALL properties must on the class. *Additionally*, a method called primitive_marker must be defined on the class.
+Return.
 
+.inside_rect? rect
 
-Here is an example:
+Return. args.inputs.mouse.inside_rect? takes in any primitive that responds to x, y, w, h:
 
-# Create type with ALL solid properties AND primitive_marker
-class Solid
-  attr_accessor :x, :y, :w, :h, :r, :g, :b, :a
-
-  def primitive_marker
-    :solid
-  end
-end
-
-# Inherit from type
-class Square < Solid
-  # constructor
-  def initialize x, y, size
-    self.x = x
-    self.y = y
-    self.w = size
-    self.h = size
-  end
-end
-
-def tick args
-  # render solid/border
-  args.outputs.solids  << Square.new(10, 10, 32)
-end
-
-DOCS: GTK::Outputs#borders
+.inside_circle? center_point, radius
 
-Add primitives to this collection to render an unfilled solid to the screen. Take a look at the documentation for Outputs#solids.
+Returns true if the mouse is inside of a specified circle. args.inputs.mouse.inside_circle? takes in any primitive that responds to x, y (which represents the circle's center), and takes in a radius:
 
+.moved
 
-The only difference between the two primitives is where they are added.
+Returns true if the mouse has moved on the current frame.
 
+.button_left
 
-Instead of using args.outputs.solids:
+Returns true if the left mouse button is down.
 
-def tick args
-  #                         X    Y  WIDTH  HEIGHT
-  args.outputs.solids << [100, 100,   160,     90]
-end
-
+.button_middle
 
-You have to use args.outputs.borders:
+Returns true if the middle mouse button is down.
 
-def tick args
-  #                           X    Y  WIDTH  HEIGHT
-  args.outputs.borders << [100, 100,   160,     90]
-end
-
-DOCS: GTK::Outputs#screenshots
+.button_right
 
-Add a hash to this collection to take a screenshot and save as png file. The keys of the hash can be provided in any order.
+Returns true if the right mouse button is down.
 
-def tick args
-  args.outputs.screenshots << {
-    x: 0, y: 0, w: 100, h: 100,    # Which portion of the screen should be captured
-    path: 'screenshot.png',        # Output path of PNG file (inside game directory)
-    r: 255, g: 255, b: 255, a: 0   # Optional chroma key
-  }
-end
-
-Chroma key (Making a color transparent)
+.button_bits
 
-By specifying the r, g, b and a keys of the hash you change the transparency of a color in the resulting PNG file. This can be useful if you want to create files with transparent background like spritesheets. The transparency of the color specified by r, g, b will be set to the transparency specified by a.
+Returns a bitmask for all buttons on the mouse: 1 for a button in the down state, 0 for a button in the up state.
 
+mouse.wheel
 
-The example above sets the color white (255, 255, 255) as transparent.
+Represents the mouse wheel. Returns nil if no mouse wheel actions occurred. ***** .x Returns the negative or positive number if the mouse wheel has changed in the x axis. ***** .y Returns the negative or positive number if the mouse wheel has changed in the y axis.
 
-DOCS: GTK::Mouse
+.click OR .down, .previous_click, .up
 
-The mouse is accessible via args.inputs.mouse:
+The properties args.inputs.mouse.(click|down|previous_click|up) each return nil if the mouse button event didn't occur. And return an Entity that has an x, y properties along with helper functions to determine collision: inside_rect?, inside_circle.
 
-def tick args
-  # Rendering a label that shows the mouse's x and y position (via args.inputs.mouse).
-  args.outputs.labels << [
-    10,
-    710,
-    "The mouse's position is: #{args.inputs.mouse.x} #{args.inputs.mouse.y}."
-  ]
-end
-
+.controller_one, .controller_two
 
-The mouse has the following properties.
+Represents controllers connected to the usb ports.
 
-
-args.inputs.mouse.x: Returns the x position of the mouse.
-args.inputs.mouse.y: Returns the y position of the mouse.
-args.inputs.mouse.moved: Returns true if the mouse moved during the tick.
-args.inputs.mouse.moved_at: Returns the tick_count (args.state.tick_count) that the mouse was moved at. This property will be nil if the mouse didn't move.
-args.inputs.mouse.global_moved_at: Returns the global tick_count (Kernel.global_tick_count) that the mouse was moved at. This property will be nil if the mouse didn't move.
-args.inputs.mouse.click: Returns a GTK::MousePoint for that specific frame (args.state.tick_count) if the mouse button was pressed.
-args.inputs.mouse.previous_click: Returns a GTK::MousePoint for the previous frame (args.state.tick_count - 1) if the mouse button was pressed.
-args.inputs.mouse.up: Returns true if for that specific frame (args.state.tick_count) if the mouse button was released.
-args.inputs.mouse.point | args.inputs.mouse.position: Returns an Array which contains the x and y position of the mouse.
-args.inputs.mouse.has_focus: Returns true if the game window has the mouse's focus.
-args.inputs.mouse.wheel: Returns an GTK::OpenEntity that contains an x and y property which represents how much the wheel has moved. If the wheel has not moved within the tick, this property will be nil.
-args.inputs.mouse.button_left: Returns true if the left mouse button is down.
-args.inputs.mouse.button_right: Returns true if the right mouse button is down.
-args.inputs.mouse.button_middle: Returns true if the middle mouse button is down.
-args.inputs.mouse.button_bits: Gives the bits for each mouse button and its current state.
-
-DOCS: GTK::MousePoint
+~.up
 
-The GTK::MousePoint has the following properties.
+Returns true if up is pressed or held on the directional or left analog.
 
-
-x: Integer representing the mouse's x.
-y: Integer representing the mouse's y.
-point: Array with the x and y values.
-w: Width of the point that always returns 0 (included so that it can seemlessly work with GTK::Geometry functions).
-h: Height of the point that always returns 0 (included so that it can seemlessly work with GTK::Geometry functions).
-left: This value is the same as x (included so that it can seemlessly work with GTK::Geometry functions).
-right: This value is the same as x (included so that it can seemlessly work with GTK::Geometry functions).
-top: This value is the same as y (included so that it can seemlessly work with GTK::Geometry functions).
-bottom: This value is the same as y (included so that it can seemlessly work with GTK::Geometry functions).
-created_at: The tick (args.state.tick_count) that this structure was created.
-global_created_at: The global tick (Kernel.global_tick_count) that this structure was created.
-
-DOCS: GTK::OpenEntity
+~.down
 
-GTK::OpenEntity is accessible within the DragonRuby's top level tick function via the args.state property.
+Returns true if down is pressed or held on the directional or left analog.
 
-def tick args
-  args.state.x ||= 100
-  args.outputs.labels << [10, 710, "value of x is: #{args.state.x}."]
-end
-
+~.left
 
-The primary benefit of using args.state as opposed to instance variables is that GTK::OpenEntity allows for arbitrary nesting of properties without the need to create intermediate objects.
+Returns true if left is pressed or held on the directional or left analog.
 
+~.right
 
-For example:
+Returns true if right is pressed or held on the directional or left analog.
 
-def tick args
-  # intermediate player object does not need to be created
-  args.state.player.x ||= 100
-  args.state.player.y ||= 100
-  args.outputs.labels << [
-    10,
-    710,
-    "player x, y is:#{args.state.player.x}, #{args.state.player.y}."
-  ]
-end
-
-DOCS: GTK::OpenEntity#as_hash
+~.left_right
 
-Returns a reference to the GTK::OpenEntity as a Hash. This property is useful when you want to treat args.state as a Hash and invoke methods such as Hash#each.
+Returns -1 (left), 0 (neutral), or +1 (right) depending on results of args.inputs.controller_(one|two).left and args.inputs.controller_(one|two).right.
 
+~.up_down
 
-Example:
+Returns -1 (down), 0 (neutral), or +1 (up) depending on results of args.inputs.controller_(one|two).up and args.inputs.controller_(one|two).down.
 
-def tick args
-  args.state.x ||= 100
-  args.state.y ||= 100
-  values = args.state
-               .as_hash
-               .map { |k, v| "#{k} #{v}" }
-
-  args.outputs.labels << values.map.with_index do |v, i|
-    [
-      10,
-      710 - (30 * i),
-      v
-    ]
-  end
-end
-
-DOCS: Numeric#frame_index
+.(left_analog_x_raw|right_analog_x_raw)
 
-This function is helpful for determining the index of frame-by-frame   sprite animation. The numeric value self represents the moment the   animation started.
+Returns the raw integer value for the analog's horizontal movement (-32,000 to +32,000).
 
+.left_analog_y_raw|right_analog_y_raw)
 
-frame_index takes three additional parameters:
+Returns the raw integer value for the analog's vertical movement (-32,000 to +32,000).
 
-
-How many frames exist in the sprite animation.
-How long to hold each animation for.
-Whether the animation should repeat.
-
+.left_analog_x_perc|right_analog_x_perc)
 
-frame_index will return nil if the time for the animation is out of bounds of the parameter specification.
+Returns a number between -1 and 1 which represents the percentage the analog is moved horizontally as a ratio of the maximum horizontal movement.
 
+.left_analog_y_perc|right_analog_y_perc)
 
-Example using variables:
+Returns a number between -1 and 1 which represents the percentage the analog is moved vertically as a ratio of the maximum vertical movement.
 
-def tick args
-  start_looping_at = 0
-  number_of_sprites = 6
-  number_of_frames_to_show_each_sprite = 4
-  does_sprite_loop = true
-
-  sprite_index =
-    start_looping_at.frame_index number_of_sprites,
-                                 number_of_frames_to_show_each_sprite,
-                                 does_sprite_loop
-
-  sprite_index ||= 0
-
-  args.outputs.sprites << [
-    640 - 50,
-    360 - 50,
-    100,
-    100,
-    "sprites/dragon-#{sprite_index}.png"
-  ]
-end
-
+.directional_up)
 
-Example using named parameters:
+Returns true if up is pressed or held on the directional.
 
-def tick args
-  start_looping_at = 0
-
-  sprite_index =
-    start_looping_at.frame_index count: 6,
-                                 hold_for: 4,
-                                 repeat: true,
-                                 tick_count_override: args.state.tick_count
-
-  sprite_index ||= 0
-
-  args.outputs.sprites << [
-    640 - 50,
-    360 - 50,
-    100,
-    100,
-    "sprites/dragon-#{sprite_index}.png"
-  ]
-end
-
-DOCS: Numeric#elapsed_time
+.directional_down)
 
-For a given number, the elapsed frames since that number is returned. `Kernel.tick_count` is used to determine how many frames have elapsed. An optional numeric argument can be passed in which will be used instead of `Kernel.tick_count`.
+Returns true if down is pressed or held on the directional.
 
+.directional_left)
 
-Here is an example of how elapsed_time can be used.
+Returns true if left is pressed or held on the directional.
 
-def tick args
-  args.state.last_click_at ||= 0
-
-  # record when a mouse click occurs
-  if args.inputs.mouse.click
-    args.state.last_click_at = args.state.tick_count
-  end
-
-  # Use Numeric#elapsed_time to determine how long it's been
-  if args.state.last_click_at.elapsed_time > 120
-    args.outputs.labels << [10, 710, "It has been over 2 seconds since the mouse was clicked."]
-  end
-end
-
+.directional_right)
 
-And here is an example where the override parameter is passed in:
+Returns true if right is pressed or held on the directional.
 
-def tick args
-  args.state.last_click_at ||= 0
-
-  # create a state variable that tracks time at half the speed of args.state.tick_count
-  args.state.simulation_tick = args.state.tick_count.idiv 2
-
-  # record when a mouse click occurs
-  if args.inputs.mouse.click
-    args.state.last_click_at = args.state.simulation_tick
-  end
-
-  # Use Numeric#elapsed_time to determine how long it's been
-  if (args.state.last_click_at.elapsed_time args.state.simulation_tick) > 120
-    args.outputs.labels << [10, 710, "It has been over 4 seconds since the mouse was clicked."]
-  end
-end
-
-DOCS: Numeric#elapsed?
+.(a|b|x|y|l1|r1|l2|r2|l3|r3|start|select)
 
-Returns true if Numeric#elapsed_time is greater than the number. An optional parameter can be passed into elapsed? which is added to the number before evaluating whether elapsed? is true.
+Returns true if the specific button is pressed or held.
 
+.truthy_keys
 
-Example usage (no optional parameter):
+Returns a collection of Symbols that represent all keys that are in the pressed or held state.
 
-def tick args
-  args.state.box_queue ||= []
-
-  if args.state.box_queue.empty?
-    args.state.box_queue << { name: :red,
-                              destroy_at: args.state.tick_count + 60 }
-    args.state.box_queue << { name: :green,
-                              destroy_at: args.state.tick_count + 60 }
-    args.state.box_queue << { name: :blue,
-                              destroy_at: args.state.tick_count + 120 }
-  end
-
-  boxes_to_destroy = args.state
-                         .box_queue
-                         .find_all { |b| b[:destroy_at].elapsed? }
-
-  if !boxes_to_destroy.empty?
-    puts "boxes to destroy count: #{boxes_to_destroy.length}"
-  end
-
-  boxes_to_destroy.each { |b| puts "box #{b} was elapsed? on #{args.state.tick_count}." }
-
-  args.state.box_queue -= boxes_to_destroy
-end
-
+.key_down
 
-Example usage (with optional parameter):
+Returns true if the specific button was pressed on this frame. args.inputs.controller_(one|two).key_down.BUTTON will only be true on the frame it was pressed.
 
-def tick args
-  args.state.box_queue ||= []
-
-  if args.state.box_queue.empty?
-    args.state.box_queue << { name: :red,
-                              create_at: args.state.tick_count + 120,
-                              lifespan: 60 }
-    args.state.box_queue << { name: :green,
-                              create_at: args.state.tick_count + 120,
-                              lifespan: 60 }
-    args.state.box_queue << { name: :blue,
-                              create_at: args.state.tick_count + 120,
-                              lifespan: 120 }
-  end
-
-  # lifespan is passed in as a parameter to ~elapsed?~
-  boxes_to_destroy = args.state
-                         .box_queue
-                         .find_all { |b| b[:create_at].elapsed? b[:lifespan] }
-
-  if !boxes_to_destroy.empty?
-    puts "boxes to destroy count: #{boxes_to_destroy.length}"
-  end
-
-  boxes_to_destroy.each { |b| puts "box #{b} was elapsed? on #{args.state.tick_count}." }
-
-  args.state.box_queue -= boxes_to_destroy
-end
-
-DOCS: Numeric#created?
+.key_held
 
-Returns true if Numeric#elapsed_time == 0. Essentially communicating that number is equal to the current frame.
+Returns true if the specific button is being held. args.inputs.controller_(one|two).key_held.BUTTON will be true for all frames after key_down (until released).
 
+.key_up
 
-Example usage:
+Returns true if the specific button was released. args.inputs.controller_(one|two).key_up.BUTTON will be true only on the frame the button was released.
 
-def tick args
-  args.state.box_queue ||= []
-
-  if args.state.box_queue.empty?
-    args.state.box_queue << { name: :red,
-                              create_at: args.state.tick_count + 60 }
-  end
-
-  boxes_to_spawn_this_frame = args.state
-                                  .box_queue
-                                  .find_all { |b| b[:create_at].new? }
-
-  boxes_to_spawn_this_frame.each { |b| puts "box #{b} was new? on #{args.state.tick_count}." }
-
-  args.state.box_queue -= boxes_to_spawn_this_frame
-end
-
-DOCS: Kernel
+.keyboard
 
-Kernel in the DragonRuby Runtime has patches for how standard out is handled and also contains a unit of time in games called a tick.
+Represents the user's keyboard
 
-DOCS: Kernel::tick_count
+.up
 
-Returns the current tick of the game. This value is reset if you call $gtk.reset.
+Returns true if up or w is pressed or held on the keyboard.
 
-DOCS: Kernel::global_tick_count
+.down
 
-Returns the current tick of the application from the point it was started. This value is never reset.
+Returns true if down or s is pressed or held on the keyboard.
 
-Open Source
+.left
 
-Follows is a source code listing for all files that have been open sourced. This code can be found in the ./samples directory and online at https://github.com/DragonRuby/dragonruby-game-toolkit-contrib/.
+Returns true if left or a is pressed or held on the keyboard.
 
-Learn Ruby Optional - Beginner Ruby Primer - automation.rb
-# ./samples/00_learn_ruby_optional/00_beginner_ruby_primer/app/automation.rb
-# ==========================================================================
-#  _    _ ________     __  _      _____  _____ _______ ______ _   _ _ _ _ _
-# | |  | |  ____\ \   / / | |    |_   _|/ ____|__   __|  ____| \ | | | | | |
-# | |__| | |__   \ \_/ /  | |      | | | (___    | |  | |__  |  \| | | | | |
-# |  __  |  __|   \   /   | |      | |  \___ \   | |  |  __| | . ` | | | | |
+.right
+
+Returns true if right or d is pressed or held on the keyboard.
+
+.left_right
+
+Returns -1 (left), 0 (neutral), or +1 (right) depending on results of args.inputs.keyboard.left and args.inputs.keyboard.right.
+
+.up_down
+
+Returns -1 (left), 0 (neutral), or +1 (right) depending on results of args.inputs.keyboard.up and args.inputs.keyboard.up.
+
+keyboard properties
+
+The following properties represent keys on the keyboard and are available on args.inputs.keyboard.KEY, args.inputs.keyboard.key_down.KEY, args.inputs.keyboard.key_held.KEY, and args.inputs.keyboard.key_up.KEY:
+
+
+alt
+meta
+control
+shift
+ctrl_KEY (dynamic method, eg args.inputs.keyboard.ctrl_a)
+exclamation_point
+zero
+one
+two
+three
+four
+five
+six
+seven
+eight
+nine
+backspace
+delete
+escape
+enter
+tab
+open_round_brace
+close_round_brace
+open_curly_brace
+close_curly_brace
+open_square_brace
+close_square_brace
+colon
+semicolon
+equal_sign
+hyphen
+space
+dollar_sign
+double_quotation_mark
+single_quotation_mark
+backtick
+tilde
+period
+comma
+pipe
+underscore
+a
+b
+c
+d
+e
+f
+g
+h
+i
+j
+k
+l
+m
+n
+o
+p
+q
+r
+s
+t
+u
+v
+w
+x
+y
+z
+shift
+control
+alt
+meta
+left
+right
+up
+down
+pageup
+pagedown
+char
+plus
+at
+forward_slash
+back_slash
+asterisk
+less_than
+greater_than
+carat
+ampersand
+superscript_two
+circumflex
+question_mark
+section_sign
+ordinal_indicator
+raw_key
+raw_key
+left_right
+up_down
+directional_vector
+truthy_keys
+
+inputs.keyboard.keys
+
+Returns a Hash with all keys on the keyboard in their respective state. The Hash contains the following keys
+
+
+:down
+:held
+:down_or_held
+:up
+
+args.outputs
+
+args.outputs.PROPERTY is how you render to the screen.
+
+.background_color
+
+Set args.outputs.background_color to an Array with RGB values (eg. [255, 255, 255] for the color white).
+
+.sounds
+
+Send a file path to this collection to play a sound. The sound file must be under the mygame directory. Example: args.outputs.sounds << "sounds/jump.wav".
+
+.solids
+
+Send a Primitive to this collection to render a filled in rectangle to the screen. This collection is cleared at the end of every frame.
+
+.static_solids
+
+Send a Primitive to this collection to render a filled in rectangle to the screen. This collection is not cleared at the end of every frame. And objects can be mutated by reference.
+
+.sprites, .static_sprites
+
+Send a Primitive to this collection to render a sprite to the screen.
+
+.primitives, .static_primitives
+
+Send a Primitive of any type and it'll be rendered. The Primitive must have a primitive_marker that returns :solid, :sprite, :label, :line, :border.
+
+.labels, .static_labels
+
+Send a Primitive to this collection to render text to the screen.
+
+.lines, .static_lines
+
+Send a Primitive to this collection to render a line to the screen.
+
+.borders, .static_borders
+
+Send a Primitive to this collection to render an unfilled rectangle to the screen.
+
+.debug, .static_debug
+
+Send any Primitive to this collection which represents things you render to the screen for debugging purposes. Primitives in this collection will not be rendered in a production release of your game.
+
+args.geometry
+
+This property contains geometric functions. Functions can be invoked via args.geometry.FUNCTION.
+
+.inside_rect? rect_1, rect_2
+
+Returns true if rect_1 is inside rect_2.
+
+.intersect_rect? rect_2, rect_2
+
+Returns true if rect_1 intersects rect_2.
+
+.scale_rect rect, x_percentage, y_percentage
+
+Returns a new rectangle that is scaled by the percentages provided.
+
+.angle_to start_point, end_point
+
+Returns the angle in degrees between two points start_point to end_point.
+
+.angle_from start_point, end_point
+
+Returns the angle in degrees between two points start_point from end_point.
+
+.point_inside_circle? point, circle_center_point, radius
+
+Returns true if a point is inside a circle defined by its center and radius.
+
+.center_inside_rect rect, other_rect
+
+Returns a new rectangle based of off rect that is centered inside of other_rect.
+
+.center_inside_rect_x rect, other_rect
+
+Returns a new rectangle based of off rect that is centered horizontally inside of other_rect.
+
+.center_inside_rect_y rect, other_rect
+
+Returns a new rectangle based of off rect that is centered vertically inside of other_rect.
+
+.anchor_rect rect, anchor_x, anchor_y
+
+Returns a new rectangle based of off rect that has been repositioned based on the percentages passed into anchor_x, and anchor_y.
+
+.shift_line line, x, y
+
+Returns a line that is offset by x, and y.
+
+.line_y_intercept line
+
+Given a line, the b value is determined for the point slope form equation: y = mx + b.
+
+.angle_between_lines line_one, line_two, replace_infinity:
+
+Returns the angle between two lines as if they were infinitely long. A numeric value can be passed in for the last parameter which would represent lines that do not intersect.
+
+.line_slope line, replace_infinity:
+
+Given a line, the m value is determined for the point slope form equation: y = mx + b.
+
+.line_rise_run
+
+Given a line, a Hash is returned that returns the slope as x and y properties with normalized values (the number is between -1 and 1).
+
+.ray_test point, line
+
+Given a point and a line, :on, :left, or :right which represents the location of the point relative to the line.
+
+.line_rect line
+
+Returns the bounding rectangle for a line.
+
+.line_intersect line_one, line_two
+
+Returns a point that represents the intersection of the lines.
+
+.distance point_one, point_two
+
+Returns the distance between two points.
+
+.cubic_bezier t, a, b, c, d
+
+Returns the cubic bezier function for tick_count t with anchors a, b, c, and d.
+
+args.easing
+
+A set of functions that allow you to determine the current progression of an easing function.
+
+.ease start_tick, current_tick, duration, easing_functions
+
+Given a start, current, duration, and easing function names, ease returns a number between 0 and 1 that represents the progress of an easing function.
+
+
+The built in easing definitions you have access to are :identity, :flip, :quad, :cube, :quart, and :quint.
+
+
+This example will move a box at a linear speed from 0 to 1280.
+
+def tick args
+  start_time = 10
+  duration = 60
+  current_progress = args.easing.ease start_time,
+                                      args.state.tick_count,
+                                      duration,
+                                      :identity
+  args.outputs.solids << { x: 1280 * current_progress, y: 360, w: 10, h: 10 }
+end
+
+.ease_spline start_tick, current_tick, duration, spline
+
+Given a start, current, duration, and a multiple bezier values, this function returns a number between 0 and 1 that represents the progress of an easing function.
+
+
+This example will move a box at a linear speed from 0 to 1280 and then back to 0 using two bezier definitions (represented as an array with four values).
+
+def tick args
+  start_time = 10
+  duration = 60
+  spline = [
+    [  0, 0.25, 0.75, 1.0],
+    [1.0, 0.75, 0.25,   0]
+  ]
+  current_progress = args.easing.ease_spline start_time,
+                                             args.state.tick_count,
+                                             duration,
+                                             spline
+  args.outputs.solids << { x: 1280 * current_progress, y: 360, w: 10, h: 10 }
+end
+
+args.string
+
+Useful string functions not included in Ruby core libraries.
+
+.wrapped_lines string, max_character_length
+
+This function will return a collection of strings given an input string and max_character_length. The collection of strings returned will split the input string into strings of length <= max_character_length.
+
+
+The following example takes a string with new lines and creates a label for each one. Labels (args.outputs.labels) ignore newline characters \n.
+
+def tick args
+  long_string = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.
+teger dolor velit, ultricies vitae libero vel, aliquam imperdiet enim."
+  max_character_length = 30
+  long_strings_split = args.string.wrapped_lines long_string, max_character_length
+  args.outputs.labels << long_strings_split.map_with_index do |s, i|
+    { x: 10, y: 600 - (i * 20), text: s }
+  end
+end
+
+args.grid
+
+Returns the virtual grid for the game.
+
+.name
+
+Returns either :origin_bottom_left or :origin_center.
+
+.bottom
+
+Returns the y value that represents the bottom of the grid.
+
+.top
+
+Returns the y value that represents the top of the grid.
+
+.left
+
+Returns the x value that represents the left of the grid.
+
+.right
+
+Returns the x value that represents the right of the grid.
+
+.rect
+
+Returns a rectangle Primitive that represents the grid.
+
+.origin_bottom_left!
+
+Change the grids coordinate system to 0, 0 at the bottom left corner.
+
+.origin_center!
+
+Change the grids coordinate system to 0, 0 at the center of the screen.
+
+.w
+
+Returns the grid's width (always 1280).
+
+.h
+
+Returns the grid's height (always 720).
+
+args.gtk
+
+This represents the DragonRuby Game Toolkit's Runtime Environment and can be accessed via args.gtk.METHOD.
+
+.argv
+
+Returns a String that represents the parameters passed into the ./dragonruby binary.
+
+.platform
+
+Returns a String representing the operating system the game is running on.
+
+.request_quit
+
+Request that the runtime quit the game.
+
+.write_file path, contents
+
+Writes/overwrites a file within the game directory + path.
+
+.write_file_root
+
+Writes/overwrites a file within the root dragonruby binary directory + path.
+
+.append_file path, contents
+
+Append content to a file located at the game directory + path.
+
+.append_file_root path, contents
+
+Append content to a file located at the root dragonruby binary directory + path.
+
+.read_file path
+
+Reads a file from the sandboxed file system.
+
+.parse_xml string, parse_xml_file path
+
+Returns a Hash for a String that represents XML.
+
+.parse_json string, parse_json_file path
+
+Returns a Hash for a String that represents JSON.
+
+.http_get url, extra_headers = {}
+
+Creates an async task to perform an HTTP GET.
+
+.http_post url, form_fields = {}, extra_headers = {}
+
+Creates an async task to perform an HTTP POST.
+
+.reset
+
+Resets the game by deleting all data in args.state and setting args.state.tick_count back to 0.
+
+.stop_music
+
+Stops all background music.
+
+.calcstringbox str, size_enum, font
+
+Returns a tuple with width and height of a string being rendered.
+
+.slowmo! factor
+
+Slows the game down by the factor provided.
+
+.notify! string
+
+Renders a toast message at the bottom of the screen.
+
+.system
+
+Invokes a shell command and prints the result to the console.
+
+.exec
+
+Invokes a shell command and returns a String that represents the result.
+
+.save_state
+
+Saves the game state to game_state.txt.
+
+.load_state
+
+Load args.state from game_state.txt.
+
+.serialize_state file, state
+
+Saves entity state to a file. If only one parameter is provided a string is returned for state instead of writing to a file.
+
+.deserialize_state file
+
+Returns entity state from a file or serialization data represented as a String.
+
+.reset_sprite path
+
+Invalids the texture cache of a sprite.
+
+.show_cursor
+
+Shows the mouse cursor.
+
+.hide_cursor
+
+Hides the mouse cursor.
+
+.cursor_shown?
+
+Returns true if the mouse cursor is shown.
+
+.set_window_fullscreen enabled
+
+Sets the game to either fullscreen (enabled=true) or windowed (enabled=false).
+
+.openurl url
+
+Opens a url using the Operating System's default browser.
+
+.get_base_dir
+
+Returns the full path of the DragonRuby binary directory.
+
+.get_game_dir
+
+Returns the full path of the game directory in its sandboxed environment.
+
+DOCS: GTK::Runtime#reset
+
+This function will reset Kernel.tick_count to 0 and will remove all data from args.state.
+
+DOCS: GTK::Runtime#calcstringbox
+
+This function returns the width and height of a string.
+
+def tick args
+  args.state.string_size           ||= args.gtk.calcstringbox "Hello World"
+  args.state.string_size_font_size ||= args.gtk.calcstringbox "Hello World"
+end
+
+DOCS: GTK::Runtime#write_file
+
+This function takes in two parameters. The first parameter is the file path and assumes the the game directory is the root. The second parameter is the string that will be written. The method overwrites whatever is currently in the file. Use GTK::Runtime#append_file to append to the file as opposed to overwriting.
+
+def tick args
+  if args.inputs.mouse.click
+    args.gtk.write_file "last-mouse-click.txt", "Mouse was clicked at #{args.state.tick_count}."
+  end
+end
+
+DOCS: Array
+
+The Array class has been extend to provide methods that will help in common game development tasks. Array is one of the most powerful classes in Ruby and a very fundamental component of Game Toolkit.
+
+DOCS: Array#map
+
+The function given a block returns a new Enumerable of values.
+
+
+Example of using Array#map in conjunction with args.state and args.outputs.sprites to render sprites to the screen.
+
+def tick args
+  # define the colors of the rainbow in ~args.state~
+  # as an ~Array~ of ~Hash~es with :order and :name.
+  # :order will be used to determine render location
+  #  and :name will be used to determine sprite path.
+  args.state.rainbow_colors ||= [
+    { order: 0, name: :red    },
+    { order: 1, name: :orange },
+    { order: 2, name: :yellow },
+    { order: 3, name: :green  },
+    { order: 4, name: :blue   },
+    { order: 5, name: :indigo },
+    { order: 6, name: :violet },
+  ]
+
+  # render sprites diagonally to the screen
+  # with a width and height of 50.
+  args.outputs
+      .sprites << args.state
+                      .rainbow_colors
+                      .map do |color| # <-- ~Array#map~ usage
+                        [
+                          color[:order] * 50,
+                          color[:order] * 50,
+                          50,
+                          50,
+                          "sprites/square-#{color[:name]}.png"
+                        ]
+                      end
+end
+
+DOCS: Array#each
+
+The function, given a block, invokes the block for each item in the Array. Array#each is synonymous to foreach constructs in other languages.
+
+
+Example of using Array#each in conjunction with args.state and args.outputs.sprites to render sprites to the screen:
+
+def tick args
+  # define the colors of the rainbow in ~args.state~
+  # as an ~Array~ of ~Hash~es with :order and :name.
+  # :order will be used to determine render location
+  #  and :name will be used to determine sprite path.
+  args.state.rainbow_colors ||= [
+    { order: 0, name: :red    },
+    { order: 1, name: :orange },
+    { order: 2, name: :yellow },
+    { order: 3, name: :green  },
+    { order: 4, name: :blue   },
+    { order: 5, name: :indigo },
+    { order: 6, name: :violet },
+  ]
+
+  # render sprites diagonally to the screen
+  # with a width and height of 50.
+  args.state
+      .rainbow_colors
+      .map do |color| # <-- ~Array#each~ usage
+        args.outputs.sprites << [
+          color[:order] * 50,
+          color[:order] * 50,
+          50,
+          50,
+          "sprites/square-#{color[:name]}.png"
+        ]
+      end
+end
+
+DOCS: Array#reject_nil
+
+Returns an Enumerable rejecting items that are nil, this is an alias for Array#compact:
+
+repl do
+  a = [1, nil, 4, false, :a]
+  puts a.reject_nil
+  # => [1, 4, false, :a]
+  puts a.compact
+  # => [1, 4, false, :a]
+end
+
+DOCS: Array#reject_false
+
+Returns an `Enumerable` rejecting items that are `nil` or `false`.
+
+repl do
+  a = [1, nil, 4, false, :a]
+  puts a.reject_false
+  # => [1, 4, :a]
+end
+
+DOCS: Array#product
+
+Returns all combinations of values between two arrays.
+
+
+Here are some examples of using product. Paste the following code at the bottom of main.rb and save the file to see the results:
+
+repl do
+  a = [0, 1]
+  puts a.product
+  # => [[0, 0], [0, 1], [1, 0], [1, 1]]
+end
+
+repl do
+  a = [ 0,  1]
+  b = [:a, :b]
+  puts a.product b
+  # => [[0, :a], [0, :b], [1, :a], [1, :b]]
+end
+
+DOCS: Array#map_2d
+
+Assuming the array is an array of arrays, Given a block, each 2D array index invoked against the block. A 2D array is a common way to store data/layout for a stage.
+
+repl do
+  stage = [
+    [:enemy, :empty, :player],
+    [:empty, :empty,  :empty],
+    [:enemy, :empty,  :enemy],
+  ]
+
+  occupied_tiles = stage.map_2d do |row, col, tile|
+    if tile == :empty
+      nil
+    else
+      [row, col, tile]
+    end
+  end.reject_nil
+
+  puts "Stage:"
+  puts stage
+
+  puts "Occupied Tiles"
+  puts occupied_tiles
+end
+
+DOCS: Array#include_any?
+
+Given a collection of items, the function will return true if any of self's items exists in the collection of items passed in:
+
+DOCS: Array#any_intersect_rect?
+
+Assuming the array contains objects that respond to left, right, top, bottom, this method returns true if any of the elements within the array intersect the object being passed in. You are given an optional parameter called tolerance which informs how close to the other rectangles the elements need to be for it to be considered intersecting.
+
+
+The default tolerance is set to 0.1, which means that the primitives are not considered intersecting unless they are overlapping by more than 0.1.
+
+repl do
+  # Here is a player class that has position and implement
+  # the ~attr_rect~ contract.
+  class Player
+    attr_rect
+    attr_accessor :x, :y, :w, :h
+
+    def initialize x, y, w, h
+      @x = x
+      @y = y
+      @w = w
+      @h = h
+    end
+
+    def serialize
+      { x: @x, y: @y, w: @w, h: @h }
+    end
+
+    def inspect
+      "#{serialize}"
+    end
+
+    def to_s
+      "#{serialize}"
+    end
+  end
+
+  # Here is a definition of two walls.
+  walls = [
+     [10, 10, 10, 10],
+     { x: 20, y: 20, w: 10, h: 10 },
+   ]
+
+  # Display the walls.
+  puts "Walls."
+  puts walls
+  puts ""
+
+  # Check any_intersect_rect? on player
+  player = Player.new 30, 20, 10, 10
+  puts "Is Player #{player} touching wall?"
+  puts (walls.any_intersect_rect? player)
+  # => false
+  # The value is false because of the default tolerance is 0.1.
+  # The overlap of the player rect and any of the wall rects is
+  # less than 0.1 (for those that intersect).
+  puts ""
+
+  player = Player.new 9, 10, 10, 10
+  puts "Is Player #{player} touching wall?"
+  puts (walls.any_intersect_rect? player)
+  # => true
+  puts ""
+end
+
+DOCS: GTK::Args#audio
+
+Hash that contains audio sources that are playing. If you want to add a new sound add a hash with keys/values as in the following example:
+
+def tick args
+  # The values below (except for input of course) are the default values that apply if you don't
+  # specify the value in the hash.
+  args.audio[:my_audio] = {
+    input: 'sound/boom.wav',  # Filename
+    x: 0.0, y: 0.0, z: 0.0,   # Relative position to the listener, x, y, z from -1.0 to 1.0
+    gain: 1.0,                # Volume (0.0 to 1.0)
+    pitch: 1.0,               # Pitch of the sound (1.0 = original pitch)
+    paused: false,            # Set to true to pause the sound at the current playback position
+    looping: false,           # Set to true to loop the sound/music until you stop it
+  }
+end
+
+
+Sounds that don't specify looping: true will be removed automatically from the hash after the playback ends. Looping sounds or sounds that should stop early must be removed manually.
+
+Audio synthesis (Pro only)
+
+Instead of a path to an audio file you can specify an array [channels, sample_rate, sound_source] for input to procedurally generate sound. You do this by providing an array of float values between -1.0 and 1.0 that describe the waveform you want to play.
+
+
+channels is the number of channels: 1 = mono, 2 = stereo
+sample_rate is the number of values per seconds you will provide to describe the audio wave
+sound_source The source of your sound. See below
+
+Sound source
+
+A sound source can be one of two things:
+
+
+A Proc object that is called on demand to generate the next samples to play. Every call should generate
+  enough samples for at least 0.1 to 0.5 seconds to get continuous playback without audio skips.   The audio will continue playing endlessly until removed, so the looping option will have no effect.
+An array of sample values that will be played back once. This is useful for procedurally generated one-off SFX.
+  looping will work as expected
+
+
+When you specify 2 for channels, then the generated sample array will be played back in an interleaved manner. The first element is the first sample for the left channel, the second element is the first sample for the right channel, the third element is the second sample for the left channel etc.
+
+Example:
+def tick args
+  sample_rate = 48000
+
+  generate_sine_wave = lambda do
+    frequency = 440.0 # A5
+    samples_per_period = (sample_rate / frequency).ceil
+    one_period = samples_per_period.map_with_index { |i|
+      Math.sin((2 * Math::PI) * (i / samples_per_period))
+    }
+    one_period * frequency # Generate 1 second worth of sound
+  end
+
+  args.audio[:my_audio] ||= {
+    input: [1, sample_rate, generate_sine_wave]
+  }
+end
+
+DOCS: GTK::Outputs
+
+Outputs is how you render primitives to the screen. The minimal setup for rendering something to the screen is via a tick method defined in mygame/app/main.rb
+
+def tick args
+  # code goes here
+end
+
+DOCS: GTK::Outputs#solids
+
+Add primitives to this collection to render a solid to the screen.
+
+Rendering a solid using an Array
+
+Creates a solid black rectangle located at 100, 100. 160 pixels wide and 90 pixels tall.
+
+def tick args
+  #                         X    Y  WIDTH  HEIGHT
+  args.outputs.solids << [100, 100,   160,     90]
+end
+
+Rendering a solid using an Array with colors and alpha
+
+The value for the color and alpha is an number between 0 and 255. The alpha property is optional and will be set to 255 if not specified.
+
+
+Creates a green solid rectangle with an opacity of 50%.
+
+def tick args
+  #                         X    Y  WIDTH  HEIGHT  RED  GREEN  BLUE  ALPHA
+  args.outputs.solids << [100, 100,   160,     90,   0,   255,    0,   128]
+end
+
+Rendering a solid using a Hash
+
+If you want a more readable invocation. You can use the following hash to create a solid. Any parameters that are not specified will be given a default value. The keys of the hash can be provided in any order.
+
+def tick args
+  args.outputs.solids << {
+    x:    0,
+    y:    0,
+    w:  100,
+    h:  100,
+    r:    0,
+    g:  255,
+    b:    0,
+    a:  255
+  }
+end
+
+Rendering a solid using a Class
+
+You can also create a class with solid/border properties and render it as a primitive. ALL properties must on the class. *Additionally*, a method called primitive_marker must be defined on the class.
+
+
+Here is an example:
+
+# Create type with ALL solid properties AND primitive_marker
+class Solid
+  attr_accessor :x, :y, :w, :h, :r, :g, :b, :a
+
+  def primitive_marker
+    :solid
+  end
+end
+
+# Inherit from type
+class Square < Solid
+  # constructor
+  def initialize x, y, size
+    self.x = x
+    self.y = y
+    self.w = size
+    self.h = size
+  end
+end
+
+def tick args
+  # render solid/border
+  args.outputs.solids  << Square.new(10, 10, 32)
+end
+
+DOCS: GTK::Outputs#borders
+
+Add primitives to this collection to render an unfilled solid to the screen. Take a look at the documentation for Outputs#solids.
+
+
+The only difference between the two primitives is where they are added.
+
+
+Instead of using args.outputs.solids:
+
+def tick args
+  #                         X    Y  WIDTH  HEIGHT
+  args.outputs.solids << [100, 100,   160,     90]
+end
+
+
+You have to use args.outputs.borders:
+
+def tick args
+  #                           X    Y  WIDTH  HEIGHT
+  args.outputs.borders << [100, 100,   160,     90]
+end
+
+DOCS: GTK::Outputs#screenshots
+
+Add a hash to this collection to take a screenshot and save as png file. The keys of the hash can be provided in any order.
+
+def tick args
+  args.outputs.screenshots << {
+    x: 0, y: 0, w: 100, h: 100,    # Which portion of the screen should be captured
+    path: 'screenshot.png',        # Output path of PNG file (inside game directory)
+    r: 255, g: 255, b: 255, a: 0   # Optional chroma key
+  }
+end
+
+Chroma key (Making a color transparent)
+
+By specifying the r, g, b and a keys of the hash you change the transparency of a color in the resulting PNG file. This can be useful if you want to create files with transparent background like spritesheets. The transparency of the color specified by r, g, b will be set to the transparency specified by a.
+
+
+The example above sets the color white (255, 255, 255) as transparent.
+
+DOCS: GTK::Mouse
+
+The mouse is accessible via args.inputs.mouse:
+
+def tick args
+  # Rendering a label that shows the mouse's x and y position (via args.inputs.mouse).
+  args.outputs.labels << [
+    10,
+    710,
+    "The mouse's position is: #{args.inputs.mouse.x} #{args.inputs.mouse.y}."
+  ]
+end
+
+
+The mouse has the following properties.
+
+
+args.inputs.mouse.x: Returns the x position of the mouse.
+args.inputs.mouse.y: Returns the y position of the mouse.
+args.inputs.mouse.moved: Returns true if the mouse moved during the tick.
+args.inputs.mouse.moved_at: Returns the tick_count (args.state.tick_count) that the mouse was moved at. This property will be nil if the mouse didn't move.
+args.inputs.mouse.global_moved_at: Returns the global tick_count (Kernel.global_tick_count) that the mouse was moved at. This property will be nil if the mouse didn't move.
+args.inputs.mouse.click: Returns a GTK::MousePoint for that specific frame (args.state.tick_count) if the mouse button was pressed.
+args.inputs.mouse.previous_click: Returns a GTK::MousePoint for the previous frame (args.state.tick_count - 1) if the mouse button was pressed.
+args.inputs.mouse.up: Returns true if for that specific frame (args.state.tick_count) if the mouse button was released.
+args.inputs.mouse.point | args.inputs.mouse.position: Returns an Array which contains the x and y position of the mouse.
+args.inputs.mouse.has_focus: Returns true if the game window has the mouse's focus.
+args.inputs.mouse.wheel: Returns an GTK::OpenEntity that contains an x and y property which represents how much the wheel has moved. If the wheel has not moved within the tick, this property will be nil.
+args.inputs.mouse.button_left: Returns true if the left mouse button is down.
+args.inputs.mouse.button_right: Returns true if the right mouse button is down.
+args.inputs.mouse.button_middle: Returns true if the middle mouse button is down.
+args.inputs.mouse.button_bits: Gives the bits for each mouse button and its current state.
+
+DOCS: GTK::MousePoint
+
+The GTK::MousePoint has the following properties.
+
+
+x: Integer representing the mouse's x.
+y: Integer representing the mouse's y.
+point: Array with the x and y values.
+w: Width of the point that always returns 0 (included so that it can seemlessly work with GTK::Geometry functions).
+h: Height of the point that always returns 0 (included so that it can seemlessly work with GTK::Geometry functions).
+left: This value is the same as x (included so that it can seemlessly work with GTK::Geometry functions).
+right: This value is the same as x (included so that it can seemlessly work with GTK::Geometry functions).
+top: This value is the same as y (included so that it can seemlessly work with GTK::Geometry functions).
+bottom: This value is the same as y (included so that it can seemlessly work with GTK::Geometry functions).
+created_at: The tick (args.state.tick_count) that this structure was created.
+global_created_at: The global tick (Kernel.global_tick_count) that this structure was created.
+
+DOCS: GTK::OpenEntity
+
+GTK::OpenEntity is accessible within the DragonRuby's top level tick function via the args.state property.
+
+def tick args
+  args.state.x ||= 100
+  args.outputs.labels << [10, 710, "value of x is: #{args.state.x}."]
+end
+
+
+The primary benefit of using args.state as opposed to instance variables is that GTK::OpenEntity allows for arbitrary nesting of properties without the need to create intermediate objects.
+
+
+For example:
+
+def tick args
+  # intermediate player object does not need to be created
+  args.state.player.x ||= 100
+  args.state.player.y ||= 100
+  args.outputs.labels << [
+    10,
+    710,
+    "player x, y is:#{args.state.player.x}, #{args.state.player.y}."
+  ]
+end
+
+DOCS: GTK::OpenEntity#as_hash
+
+Returns a reference to the GTK::OpenEntity as a Hash. This property is useful when you want to treat args.state as a Hash and invoke methods such as Hash#each.
+
+
+Example:
+
+def tick args
+  args.state.x ||= 100
+  args.state.y ||= 100
+  values = args.state
+               .as_hash
+               .map { |k, v| "#{k} #{v}" }
+
+  args.outputs.labels << values.map.with_index do |v, i|
+    [
+      10,
+      710 - (30 * i),
+      v
+    ]
+  end
+end
+
+DOCS: Numeric#frame_index
+
+This function is helpful for determining the index of frame-by-frame   sprite animation. The numeric value self represents the moment the   animation started.
+
+
+frame_index takes three additional parameters:
+
+
+How many frames exist in the sprite animation.
+How long to hold each animation for.
+Whether the animation should repeat.
+
+
+frame_index will return nil if the time for the animation is out of bounds of the parameter specification.
+
+
+Example using variables:
+
+def tick args
+  start_looping_at = 0
+  number_of_sprites = 6
+  number_of_frames_to_show_each_sprite = 4
+  does_sprite_loop = true
+
+  sprite_index =
+    start_looping_at.frame_index number_of_sprites,
+                                 number_of_frames_to_show_each_sprite,
+                                 does_sprite_loop
+
+  sprite_index ||= 0
+
+  args.outputs.sprites << [
+    640 - 50,
+    360 - 50,
+    100,
+    100,
+    "sprites/dragon-#{sprite_index}.png"
+  ]
+end
+
+
+Example using named parameters:
+
+def tick args
+  start_looping_at = 0
+
+  sprite_index =
+    start_looping_at.frame_index count: 6,
+                                 hold_for: 4,
+                                 repeat: true,
+                                 tick_count_override: args.state.tick_count
+
+  sprite_index ||= 0
+
+  args.outputs.sprites << [
+    640 - 50,
+    360 - 50,
+    100,
+    100,
+    "sprites/dragon-#{sprite_index}.png"
+  ]
+end
+
+DOCS: Numeric#elapsed_time
+
+For a given number, the elapsed frames since that number is returned. `Kernel.tick_count` is used to determine how many frames have elapsed. An optional numeric argument can be passed in which will be used instead of `Kernel.tick_count`.
+
+
+Here is an example of how elapsed_time can be used.
+
+def tick args
+  args.state.last_click_at ||= 0
+
+  # record when a mouse click occurs
+  if args.inputs.mouse.click
+    args.state.last_click_at = args.state.tick_count
+  end
+
+  # Use Numeric#elapsed_time to determine how long it's been
+  if args.state.last_click_at.elapsed_time > 120
+    args.outputs.labels << [10, 710, "It has been over 2 seconds since the mouse was clicked."]
+  end
+end
+
+
+And here is an example where the override parameter is passed in:
+
+def tick args
+  args.state.last_click_at ||= 0
+
+  # create a state variable that tracks time at half the speed of args.state.tick_count
+  args.state.simulation_tick = args.state.tick_count.idiv 2
+
+  # record when a mouse click occurs
+  if args.inputs.mouse.click
+    args.state.last_click_at = args.state.simulation_tick
+  end
+
+  # Use Numeric#elapsed_time to determine how long it's been
+  if (args.state.last_click_at.elapsed_time args.state.simulation_tick) > 120
+    args.outputs.labels << [10, 710, "It has been over 4 seconds since the mouse was clicked."]
+  end
+end
+
+DOCS: Numeric#elapsed?
+
+Returns true if Numeric#elapsed_time is greater than the number. An optional parameter can be passed into elapsed? which is added to the number before evaluating whether elapsed? is true.
+
+
+Example usage (no optional parameter):
+
+def tick args
+  args.state.box_queue ||= []
+
+  if args.state.box_queue.empty?
+    args.state.box_queue << { name: :red,
+                              destroy_at: args.state.tick_count + 60 }
+    args.state.box_queue << { name: :green,
+                              destroy_at: args.state.tick_count + 60 }
+    args.state.box_queue << { name: :blue,
+                              destroy_at: args.state.tick_count + 120 }
+  end
+
+  boxes_to_destroy = args.state
+                         .box_queue
+                         .find_all { |b| b[:destroy_at].elapsed? }
+
+  if !boxes_to_destroy.empty?
+    puts "boxes to destroy count: #{boxes_to_destroy.length}"
+  end
+
+  boxes_to_destroy.each { |b| puts "box #{b} was elapsed? on #{args.state.tick_count}." }
+
+  args.state.box_queue -= boxes_to_destroy
+end
+
+
+Example usage (with optional parameter):
+
+def tick args
+  args.state.box_queue ||= []
+
+  if args.state.box_queue.empty?
+    args.state.box_queue << { name: :red,
+                              create_at: args.state.tick_count + 120,
+                              lifespan: 60 }
+    args.state.box_queue << { name: :green,
+                              create_at: args.state.tick_count + 120,
+                              lifespan: 60 }
+    args.state.box_queue << { name: :blue,
+                              create_at: args.state.tick_count + 120,
+                              lifespan: 120 }
+  end
+
+  # lifespan is passed in as a parameter to ~elapsed?~
+  boxes_to_destroy = args.state
+                         .box_queue
+                         .find_all { |b| b[:create_at].elapsed? b[:lifespan] }
+
+  if !boxes_to_destroy.empty?
+    puts "boxes to destroy count: #{boxes_to_destroy.length}"
+  end
+
+  boxes_to_destroy.each { |b| puts "box #{b} was elapsed? on #{args.state.tick_count}." }
+
+  args.state.box_queue -= boxes_to_destroy
+end
+
+DOCS: Numeric#created?
+
+Returns true if Numeric#elapsed_time == 0. Essentially communicating that number is equal to the current frame.
+
+
+Example usage:
+
+def tick args
+  args.state.box_queue ||= []
+
+  if args.state.box_queue.empty?
+    args.state.box_queue << { name: :red,
+                              create_at: args.state.tick_count + 60 }
+  end
+
+  boxes_to_spawn_this_frame = args.state
+                                  .box_queue
+                                  .find_all { |b| b[:create_at].new? }
+
+  boxes_to_spawn_this_frame.each { |b| puts "box #{b} was new? on #{args.state.tick_count}." }
+
+  args.state.box_queue -= boxes_to_spawn_this_frame
+end
+
+DOCS: Kernel
+
+Kernel in the DragonRuby Runtime has patches for how standard out is handled and also contains a unit of time in games called a tick.
+
+DOCS: Kernel::tick_count
+
+Returns the current tick of the game. This value is reset if you call $gtk.reset.
+
+DOCS: Kernel::global_tick_count
+
+Returns the current tick of the application from the point it was started. This value is never reset.
+
+DOCS: Geometry
+
+The Geometry module contains methods for calculations that are frequently used in game development.
+
+DOCS: GTK::Geometry#scale_rect
+
+Given an array with 4 elements representing a rect [x, y, w, h], this function returns a scaled rect. It accepts three arguments:
+
+
+ratio: the ratio by which to scale the rect. A ratio of 2 will double the dimensions of the rect while a ratio of 0.5 will halve its dimensions.
+
+
+anchor_x and anchor_y specify the point within the rect from which to resize it. Setting both to 0 will affect the width and height of the rect, leaving x and y unchanged. Setting both to 0.5 will scale all sides of the rect proportionally from the center.
+
+
+The scale_rect method can be applied directly to a sprite or other primitives. See CHEATSHEET: How to Scale a Sprite.
+
+def tick args
+  #       x,   y,   w,   h
+  my_rect = [100, 100, 200, 200]
+
+  # halve the dimensions of the rect:
+  #                             ratio, anchor_x, anchor_y
+  new_rect = my_rect.scale_rect(0.5,   0.5,      0.5)
+
+  puts new_rect # => [150.0, 150.0, 100.0, 100.0]
+end
+
+Source Code
+
+Follows is a source code listing for all files that have been open sourced. This code can be found in the ./samples directory.
+
+Samples
+Learn Ruby Optional - Beginner Ruby Primer - automation.rb
+# ./samples/00_learn_ruby_optional/00_beginner_ruby_primer/app/automation.rb
+# ==========================================================================
+#  _    _ ________     __  _      _____  _____ _______ ______ _   _ _ _ _ _
+# | |  | |  ____\ \   / / | |    |_   _|/ ____|__   __|  ____| \ | | | | | |
+# | |__| | |__   \ \_/ /  | |      | | | (___    | |  | |__  |  \| | | | | |
+# |  __  |  __|   \   /   | |      | |  \___ \   | |  |  __| | . ` | | | | |
+# | |  | | |____   | |    | |____ _| |_ ____) |  | |  | |____| |\  |_|_|_|_|
+# |_|  |_|______|  |_|    |______|_____|_____/   |_|  |______|_| \_(_|_|_|_)
+#
+#
+#                                   |
+#                                   |
+#                                   |
+#                                   |
+#                                   |
+#                                   |
+#                                   |
+#                                   |
+#                                   |
+#                                   |
+#                                \  |  /
+#                                 \ | /
+#                                   +
+#
+# If you are new to the programming language Ruby, then you may find the
+# following code a bit overwhelming. Come back to this file when you have
+# a better grasp of Ruby and Game Toolkit.
+#
+# What follows is an automations script # that can be run via terminal:
+# ./samples/00_beginner_ruby_primer $ ../../dragonruby . --eval app/automation.rb
+# ==========================================================================
+
+$gtk.reset
+$gtk.scheduled_callbacks.clear
+$gtk.schedule_callback 10 do
+  $gtk.console.set_command 'puts "Hello DragonRuby!"'
+end
+
+$gtk.schedule_callback 20 do
+  $gtk.console.eval_the_set_command
+end
+
+$gtk.schedule_callback 30 do
+  $gtk.console.set_command 'outputs.solids << [910, 200, 100, 100, 255, 0, 0]'
+end
+
+$gtk.schedule_callback 40 do
+  $gtk.console.eval_the_set_command
+end
+
+$gtk.schedule_callback 50 do
+  $gtk.console.set_command 'outputs.solids << [1010, 200, 100, 100, 0, 0, 255]'
+end
+
+$gtk.schedule_callback 60 do
+  $gtk.console.eval_the_set_command
+end
+
+$gtk.schedule_callback 70 do
+  $gtk.console.set_command 'outputs.sprites << [1110, 200, 100, 100, "sprites/dragon_fly_0.png"]'
+end
+
+$gtk.schedule_callback 80 do
+  $gtk.console.eval_the_set_command
+end
+
+$gtk.schedule_callback 90 do
+  $gtk.console.set_command "outputs.labels << [1210, 200, state.tick_count, 0, 255, 0]"
+end
+
+$gtk.schedule_callback 100 do
+  $gtk.console.eval_the_set_command
+end
+
+$gtk.schedule_callback 110 do
+  $gtk.console.set_command "state.sprite_frame = state.tick_count.idiv(4).mod(6)"
+end
+
+$gtk.schedule_callback 120 do
+  $gtk.console.eval_the_set_command
+end
+
+$gtk.schedule_callback 130 do
+  $gtk.console.set_command "outputs.labels << [1210, 170, state.sprite_frame, 0, 255, 0]"
+end
+
+$gtk.schedule_callback 140 do
+  $gtk.console.eval_the_set_command
+end
+
+$gtk.schedule_callback 150 do
+  $gtk.console.set_command "state.sprite_path =  \"sprites/dragon_fly_\#{state.sprite_frame}.png\""
+end
+
+$gtk.schedule_callback 160 do
+  $gtk.console.eval_the_set_command
+end
+
+$gtk.schedule_callback 170 do
+  $gtk.console.set_command "outputs.labels    << [910, 330, \"path: \#{state.sprite_path}\", 0, 255, 0]"
+end
+
+$gtk.schedule_callback 180 do
+  $gtk.console.eval_the_set_command
+end
+
+$gtk.schedule_callback 190 do
+  $gtk.console.set_command "outputs.sprites   << [910, 330, 370, 370, state.sprite_path]"
+end
+
+$gtk.schedule_callback 200 do
+  $gtk.console.eval_the_set_command
+end
+
+$gtk.schedule_callback 300 do
+  $gtk.console.set_command ":wq"
+end
+
+$gtk.schedule_callback 400 do
+  $gtk.console.eval_the_set_command
+end
+
+
+Learn Ruby Optional - Beginner Ruby Primer - main.rb
+# ./samples/00_learn_ruby_optional/00_beginner_ruby_primer/app/main.rb
+# ==========================================================================
+#  _    _ ________     __  _      _____  _____ _______ ______ _   _ _ _ _ _
+# | |  | |  ____\ \   / / | |    |_   _|/ ____|__   __|  ____| \ | | | | | |
+# | |__| | |__   \ \_/ /  | |      | | | (___    | |  | |__  |  \| | | | | |
+# |  __  |  __|   \   /   | |      | |  \___ \   | |  |  __| | . ` | | | | |
 # | |  | | |____   | |    | |____ _| |_ ____) |  | |  | |____| |\  |_|_|_|_|
 # |_|  |_|______|  |_|    |______|_____|_____/   |_|  |______|_| \_(_|_|_|_)
 #
 #
-#                                   |
-#                                   |
-#                                   |
-#                                   |
-#                                   |
-#                                   |
-#                                   |
-#                                   |
-#                                   |
-#                                   |
-#                                \  |  /
-#                                 \ | /
-#                                   +
+#                                   |
+#                                   |
+#                                   |
+#                                   |
+#                                   |
+#                                   |
+#                                   |
+#                                   |
+#                                   |
+#                                   |
+#                                \  |  /
+#                                 \ | /
+#                                   +
+#
+# If you are new to the programming language Ruby, then you may find the
+# following code a bit overwhelming. This sample is only designed to be
+# run interactively (as opposed to being manipulated via source code).
+#
+# Start up this sample and follow along by visiting:
+# https://s3.amazonaws.com/s3.dragonruby.org/dragonruby-gtk-primer.mp4
+#
+# It is STRONGLY recommended that you work through all the samples before
+# looking at the code in this file.
+# ==========================================================================
+
+class TutorialOutputs
+  attr_accessor :solids, :sprites, :labels, :lines, :borders
+
+  def initialize
+    @solids  = []
+    @sprites = []
+    @labels  = []
+    @lines   = []
+    @borders = []
+  end
+
+  def tick
+    @solids  ||= []
+    @sprites ||= []
+    @labels  ||= []
+    @lines   ||= []
+    @borders ||= []
+    @solids.each  { |p| $gtk.args.outputs.reserved << p.solid  }
+    @sprites.each { |p| $gtk.args.outputs.reserved << p.sprite }
+    @labels.each  { |p| $gtk.args.outputs.reserved << p.label  }
+    @lines.each   { |p| $gtk.args.outputs.reserved << p.line   }
+    @borders.each { |p| $gtk.args.outputs.reserved << p.border }
+  end
+
+  def clear
+    @solids.clear
+    @sprites.clear
+    @labels.clear
+    @borders.clear
+  end
+end
+
+def defaults
+  state.reset_button ||=
+    state.new_entity(
+      :button,
+      label:  [1190, 68, "RESTART", -2, 0, 0, 0, 0].label,
+      background: [1160, 38, 120, 50, 255, 255, 255].solid
+    )
+  $gtk.log_level = :off
+end
+
+def tick_reset_button
+  return unless state.hello_dragonruby_confirmed
+  $gtk.args.outputs.reserved << state.reset_button.background
+  $gtk.args.outputs.reserved << state.reset_button.label
+  if inputs.mouse.click && inputs.mouse.click.point.inside_rect?(state.reset_button.background)
+    restart_tutorial
+  end
+end
+
+def seperator
+  @seperator = "=" * 80
+end
+
+def tick_intro
+  queue_message "Welcome to the DragonRuby GTK primer! Try typing the
+code below and press ENTER:
+
+    puts \"Hello DragonRuby!\"
+"
+end
+
+def tick_hello_dragonruby
+  return unless console_has? "Hello DragonRuby!"
+
+  $gtk.args.state.hello_dragonruby_confirmed = true
+
+  queue_message "Well HELLO to you too!
+
+If you ever want to RESTART the tutorial, just click the \"RESTART\"
+button in the bottom right-hand corner.
+
+Let's continue shall we? Type the code below and press ENTER:
+
+    outputs.solids << [910, 200, 100, 100, 255, 0, 0]
+"
+
+end
+
+def tick_explain_solid
+  return unless $tutorial_outputs.solids.any? {|s| s == [910, 200, 100, 100, 255, 0, 0]}
+
+  queue_message "Sweet!
+
+The code: outputs.solids << [910, 200, 100, 100, 255, 0, 0]
+Does the following:
+1. GET the place where SOLIDS go: outputs.solids
+2. Request that a new SOLID be ADDED: <<
+3. The DEFINITION of a SOLID is the ARRAY:
+   [910, 200, 100, 100, 255, 0, 0]
+
+      GET       ADD     X      Y    WIDTH  HEIGHT RED  GREEN  BLUE
+       |         |      |      |      |      |     |     |     |
+       |         |      |      |      |      |     |     |     |
+outputs.solids  <<    [910,   200,   100,   100,  255,   0,    0]
+                      |_________________________________________|
+                                           |
+                                           |
+                                         ARRAY
+
+Now let's create a blue SOLID. Type:
+
+    outputs.solids << [1010, 200, 100, 100, 0, 0, 255]
+"
+
+  state.explain_solid_confirmed = true
+end
+
+def tick_explain_solid_blue
+  return unless state.explain_solid_confirmed
+  return unless $tutorial_outputs.solids.any? {|s| s == [1010, 200, 100, 100, 0, 0, 255]}
+  state.explain_solid_blue_confirmed = true
+
+  queue_message "And there is our blue SOLID!
+
+The ARRAY is the MOST important thing in DragonRuby GTK.
+
+Let's create a SPRITE using an ARRAY:
+
+  outputs.sprites << [1110, 200, 100, 100, 'sprites/dragon_fly_0.png']
+"
+end
+
+def tick_explain_tick_count
+  return unless $tutorial_outputs.sprites.any? {|s| s == [1110, 200, 100, 100, 'sprites/dragon_fly_0.png']}
+  return if $tutorial_outputs.labels.any? {|l| l == [1210, 200, state.tick_count, 255, 255, 255]}
+  state.explain_tick_count_confirmed = true
+
+  queue_message "Look at the cute little dragon!
+
+We can create a LABEL with ARRAYS too. Let's create a LABEL showing
+THE PASSAGE OF TIME, which is called TICK_COUNT.
+
+  outputs.labels << [1210, 200, state.tick_count, 0, 255, 0]
+"
+end
+
+def tick_explain_mod
+  return unless $tutorial_outputs.labels.any? {|l| l == [1210, 200, state.tick_count, 0, 255, 0]}
+  state.explain_mod_confirmed = true
+  queue_message "
+The code: outputs.labels << [1210, 200, state.tick_count, 0, 255, 0]
+Does the following:
+1. GET the place where labels go: outputs.labels
+2. Request that a new label be ADDED: <<
+3. The DEFINITION of a LABEL is the ARRAY:
+   [1210, 200, state.tick_count, 0, 255, 0]
+
+      GET       ADD     X      Y          TEXT         RED  GREEN  BLUE
+       |         |      |      |            |           |     |     |
+       |         |      |      |            |           |     |     |
+outputs.labels  <<    [1210,  200,   state.tick_count,  0,   255,   0]
+                      |______________________________________________|
+                                              |
+                                              |
+                                            ARRAY
+
+Now let's do some MATH, save the result to STATE, and create a LABEL:
+
+    state.sprite_frame = state.tick_count.idiv(4).mod(6)
+    outputs.labels << [1210, 170, state.sprite_frame, 0, 255, 0]
+
+Type the lines above (pressing ENTER after each line).
+"
+end
+
+def tick_explain_string_interpolation
+  return unless state.explain_mod_confirmed
+  return unless state.sprite_frame == state.tick_count.idiv(4).mod(6)
+  return unless $tutorial_outputs.labels.any? {|l| l == [1210, 170, state.sprite_frame, 0, 255, 0]}
+
+  queue_message "Here is what the mathematical computation you just typed does:
+
+1. Create an item of STATE named SPRITE_FRAME: state.sprite_frame =
+2. Set this SPRITE_FRAME to the PASSAGE OF TIME (tick_count),
+   DIVIDED EVENLY (idiv) into 4,
+   and then compute the REMAINDER (mod) of 6.
+
+   STATE   SPRITE_FRAME    PASSAGE OF      HOW LONG   HOW MANY
+     |          |             TIME         TO SHOW    IMAGES
+     |          |              |           AN IMAGE   TO FLIP THROUGH
+     |          |              |               |      |
+state.sprite_frame =     state.tick_count.idiv(4).mod(6)
+                                           |       |
+                                           |       +- REMAINDER OF DIVIDE
+                                    DIVIDE EVENLY
+                                    (NO DECIMALS)
+
+With the information above, we can animate a SPRITE
+using STRING INTERPOLATION: \#{}
+which creates a unique SPRITE_PATH:
+
+  state.sprite_path =  \"sprites/dragon_fly_\#{state.sprite_frame}.png\"
+  outputs.labels    << [910, 330, \"path: \#{state.sprite_path}\", 0, 255, 0]
+  outputs.sprites   << [910, 330, 370, 370, state.sprite_path]
+
+Type the lines above (pressing ENTER after each line).
+"
+end
+
+def tick_reprint_on_error
+  return unless console.last_command_errored
+  puts $gtk.state.messages.last
+  puts "\nWhoops! Try again."
+  console.last_command_errored = false
+end
+
+def tick_evals
+  state.evals ||= []
+  if console.last_command && (console.last_command.start_with?("outputs.") || console.last_command.start_with?("state."))
+    state.evals << console.last_command
+    console.last_command = nil
+  end
+
+  state.evals.each do |l|
+    Kernel.eval l
+  end
+rescue Exception => e
+  state.evals = state.evals[0..-2]
+end
+
+$tutorial_outputs ||= TutorialOutputs.new
+
+def tick args
+  $gtk.log_level = :off
+  defaults
+  console.show
+  $tutorial_outputs.clear
+  $tutorial_outputs.solids  << [900, 37, 480, 700,   0,   0,   0, 255]
+  $tutorial_outputs.borders << [900, 37, 380, 683, 255, 255, 255]
+  tick_evals
+  $tutorial_outputs.tick
+  tick_intro
+  tick_hello_dragonruby
+  tick_reset_button
+  tick_explain_solid
+  tick_explain_solid_blue
+  tick_reprint_on_error
+  tick_explain_tick_count
+  tick_explain_mod
+  tick_explain_string_interpolation
+end
+
+def console
+  $gtk.console
+end
+
+def queue_message message
+  $gtk.args.state.messages ||= []
+  return if $gtk.args.state.messages.include? message
+  $gtk.args.state.messages << message
+  last_three = [$gtk.console.log[-3], $gtk.console.log[-2], $gtk.console.log[-1]].reject_nil
+  $gtk.console.log.clear
+  puts seperator
+  $gtk.console.log += last_three
+  puts seperator
+  puts message
+  puts seperator
+end
+
+def console_has? message
+  console.log.map(&:upcase).include? "#{message.upcase}\n"
+end
+
+def restart_tutorial
+  $tutorial_outputs.clear
+  $gtk.console.log.clear
+  $gtk.reset
+  puts "Starting the tutorial over!"
+end
+
+def state
+  $gtk.args.state
+end
+
+def inputs
+  $gtk.args.inputs
+end
+
+def outputs
+  $tutorial_outputs
+end
+
+
+Learn Ruby Optional - Intermediate Ruby Primer - printing.txt
+# ./samples/00_learn_ruby_optional/00_intermediate_ruby_primer/app/01_printing.txt
+# ====================================================================================
+# Commenting Code
+# ====================================================================================
+#
+# Prefixing text with a pound sign (#) is how you comment code in Ruby. Example:
+#
+# I am commented code. And so are the lines above.
+#
+# I you want more than a quick primer on Ruby, check out https://poignant.guide/. It's
+# an entertaining read. Otherwise, go to the next txt file.
+#
+# Follow along by visiting:
+# https://s3.amazonaws.com/s3.dragonruby.org/dragonruby-gtk-intermediate.mp4
+
+# ====================================================================================
+#  Printing to the Console:
+# ====================================================================================
+#
+# Every time you save repl.rb file, DragonRuby runs the code within it. Copy this text
+# to repl.rb and save to see Hello World printed to the console.
+
+repl do
+  puts '* RUBY PRIMER: Printing to the console using the ~puts~ function.'
+  puts '===='
+  puts '======'
+  puts '================================'
+  puts 'Hello World'
+  puts '================================'
+  puts '======'
+  puts '===='
+end
+
+
+Learn Ruby Optional - Intermediate Ruby Primer - strings.txt
+# ./samples/00_learn_ruby_optional/00_intermediate_ruby_primer/app/02_strings.txt
+# ====================================================================================
+#  Strings
+# ====================================================================================
+#
+# Here is how you work with strings in Ruby. Take the text
+# in this file and paste it into repl.rb and save:
+
+repl do
+  puts '* RUBY PRIMER: strings'
+  message = "Hello World"
+  puts "The value of message is: " + message
+  puts "Any value can be interpolated within a string using \#{}."
+  puts "Interpolated message: #{message}."
+  puts 'This #{message} is not interpolated because the string uses single quotes.'
+end
+
+
+Learn Ruby Optional - Intermediate Ruby Primer - numbers.txt
+# ./samples/00_learn_ruby_optional/00_intermediate_ruby_primer/app/03_numbers.txt
+# ====================================================================================
+#  Numerics
+# ====================================================================================
+#
+# Here is how you work with numbers in Ruby. Take the text
+# in this file and paste it into repl.rb and save:
+
+repl do
+  puts '* RUBY PRIMER: Fixnum and Floats'
+  a = 10
+  puts "The value of a is: #{a}"
+  puts "a + 1 is: #{a + 1}"
+  puts "a / 3 is: #{a / 3}"
+  puts ''
+
+  b = 10.12
+  puts "The value of b is: #{b}"
+  puts "b + 1 is: #{b + 1}"
+  puts "b as an integer is: #{b.to_i}"
+  puts ''
+end
+
+
+Learn Ruby Optional - Intermediate Ruby Primer - booleans.txt
+# ./samples/00_learn_ruby_optional/00_intermediate_ruby_primer/app/04_booleans.txt
+# ====================================================================================
+#  Booleans
+# ====================================================================================
+#
+# Here is how you work with numbers in Ruby. Take the text
+# in this file and paste it into repl.rb and save:
+
+repl do
+  puts '* RUBY PRIMER: TrueClass, FalseClass, NilClass (truthy / falsey values)'
+  puts "Anything that *isn't* false or nil is true."
+
+  c = 30
+  puts "The value of c is #{c}."
+
+  if c
+    puts "This if statement ran because c is truthy."
+  end
+
+  d = false
+  puts "The value if d is #{d}. The type for d is #{d.class}."
+
+  if !d
+    puts "This if statement ran because d is falsey, using the not operator (!)."
+  end
+
+  e = nil
+  puts "Nil is also considered falsey. The value of e is: #{e} (a blank string when printed). Which is of type #{e.class}."
+
+  if !e
+    puts "This if statement ran because e is nil and the if statement applied the NOT operator. !e yields a type of #{(!e).class}."
+  end
+end
+
+
+Learn Ruby Optional - Intermediate Ruby Primer - conditionals.txt
+# ./samples/00_learn_ruby_optional/00_intermediate_ruby_primer/app/05_conditionals.txt
+# ====================================================================================
+#  Conditionals
+# ====================================================================================
 #
-# If you are new to the programming language Ruby, then you may find the
-# following code a bit overwhelming. Come back to this file when you have
-# a better grasp of Ruby and Game Toolkit.
+# Here is how you create conditionals in Ruby. Take the text
+# in this file and paste it into repl.rb and save:
+
+repl do
+  puts "* RUBY PRIMER: Conditionals"
+end
+
+# ====================================================================================
+#  if
+# ====================================================================================
+
+repl do
+  puts "** INFO: if statement"
+  i_am_one = 1
+  if i_am_one
+    puts "This was printed because i_am_one is truthy."
+  end
+end
+
+# ====================================================================================
+#  if/else
+# ====================================================================================
+
+repl do
+  puts "** INFO: if/else statement"
+  i_am_false = false
+  if i_am_false
+    puts "This will NOT get printed because i_am_false is false."
+  else
+    puts "This was printed because i_am_false is false."
+  end
+end
+
+
+# ====================================================================================
+#  if/elsif/else
+# ====================================================================================
+
+repl do
+  puts "** INFO: if/elsif/else statement"
+  i_am_false = false
+  i_am_true  = true
+  if i_am_false
+    puts "This will NOT get printed because i_am_false is false."
+  elsif i_am_true
+    puts "This was printed because i_am_true is true."
+  else
+    puts "This will NOT get printed i_am_true was true."
+  end
+end
+
+# ====================================================================================
+#  case
+# ====================================================================================
+
+repl do
+  puts "** INFO case statement"
+  i_am_one = 1 # change this value to see different results
+
+  case i_am_one
+  when 10
+    puts "the value of i_am_one is 10"
+  when 9
+    puts "the value of i_am_one is 9"
+  when 5
+    puts "the value of i_am_one is 5"
+  when 1
+    puts "the value of i_am_one is 1"
+  else
+    puts "Value wasn't cased."
+  end
+end
+
+# ====================================================================================
+#  comparison operators
+# ====================================================================================
+
+repl do
+  puts "** INFO: Different types of comparisons"
+  if 4 == 4
+    puts "4 equals 4 (==)"
+  end
+
+  if 4 != 3
+    puts "4 does not equal 3 (!=)"
+  end
+
+  if 3 < 4
+    puts "3 is less than 4 (<)"
+  end
+
+  if 4 > 3
+    puts "4 is greater than 3 (>)"
+  end
+end
+
+# ====================================================================================
+#  and/or conditionals
+# ====================================================================================
+
+repl do
+  puts "** INFO: AND, OR operator (&&, ||)"
+  if (4 > 3) || (3 < 4) || false
+    puts "print this if 4 is greater than 3 OR 3 is less than 4 OR false is true (||)"
+  end
+
+  if (4 > 3) && (3 < 4)
+    puts "print this if 4 is greater than 3 AND 3 is less than 4 (&&)"
+  end
+end
+
+
+Learn Ruby Optional - Intermediate Ruby Primer - looping.txt
+# ./samples/00_learn_ruby_optional/00_intermediate_ruby_primer/app/06_looping.txt
+# ====================================================================================
+#  Looping
+# ====================================================================================
 #
-# What follows is an automations script # that can be run via terminal:
-# ./samples/00_beginner_ruby_primer $ ../../dragonruby . --eval app/automation.rb
-# ==========================================================================
+# Looping looks a whole lot different than other languages.
+# But it's pretty awesome when you get used to it.
+
+repl do
+  puts "* RUBY PRIMER: Loops"
+end
+
+# ====================================================================================
+#  times
+# ====================================================================================
+
+repl do
+  puts "** INFO: ~Numeric#times~ (for loop)"
+  3.times do |i|
+    puts i
+  end
+end
+
+# ====================================================================================
+#  foreach
+# ====================================================================================
+
+repl do
+  puts "** INFO: ~Array#each~ (for each loop)"
+  array = ["a", "b", "c", "d"]
+  array.each do |char|
+    puts char
+  end
+
+  puts "** INFO: ~Array#each_with_index~ (for each loop)"
+  array = ["a", "b", "c", "d"]
+  array.each do |char, i|
+    puts "index #{i}: #{char}"
+  end
+end
+
+# ====================================================================================
+#  ranges
+# ====================================================================================
+
+repl do
+  puts "** INFO: range block exclusive (three dots)"
+  (0...3).each do |i|
+    puts i
+  end
+
+  puts "** INFO: range block inclusive (two dots)"
+  (0..3).each do |i|
+    puts i
+  end
+end
+
+
+Learn Ruby Optional - Intermediate Ruby Primer - functions.txt
+# ./samples/00_learn_ruby_optional/00_intermediate_ruby_primer/app/07_functions.txt
+# ====================================================================================
+# Functions
+# ====================================================================================
+
+# The last statement of a function is implictly returned. Parenthesis for functions
+# are optional as long as the statement can be envaluated disambiguously.
+
+repl do
+  puts "* RUBY PRIMER: Functions"
+end
+
+# ====================================================================================
+# Functions single parameter
+# ====================================================================================
+
+repl do
+  puts "* INFO: Function with one parameter"
+
+  # function definition
+  def add_one_to n
+    n + 1
+  end
+
+  # Parenthesis are optional in Ruby as long as the
+  # parsing is disambiguous. Here are a couple of variations.
+  # Generally speaking, don't put parenthesis is you don't have to.
+
+  # Conventional Usage of Parenthesis.
+  puts add_one_to(3)
+
+  # DragonRuby's recommended use of parenthesis (inner function has parenthesis).
+  puts (add_one_to 3)
+
+  # Full parens.
+  puts(add_one_to(3))
+
+  # Outer function has parenthesis
+  puts(add_one_to 3)
+end
+
+# ====================================================================================
+# Functions with default parameter values
+# ====================================================================================
+
+repl do
+  puts "* INFO: Function with default value"
+  def function_with_default_value v = 10
+    v * 10
+  end
+
+  puts "Passing the argument three yields: #{function_with_default_value 3}"
+  puts "Passing no argument yields: #{function_with_default_value}"
+end
+
+# ====================================================================================
+# Nil default parameter value and ||= operator.
+# ====================================================================================
+
+repl do
+  puts "* INFO: Using the OR EQUAL operator (||=)"
+  def function_with_nil_default_with_local a = nil
+    result   = a
+    result ||= "DEFAULT_VALUE_OF_A_IS_NIL_OR_FALSE"
+    "value is #{result}."
+  end
+
+  puts "Passing 'hi' as the argument yields: #{function_with_nil_default_with_local 'hi'}"
+  puts "Passing nil: #{function_with_nil_default_with_local}"
+end
+
+
+Learn Ruby Optional - Intermediate Ruby Primer - arrays.txt
+# ./samples/00_learn_ruby_optional/00_intermediate_ruby_primer/app/08_arrays.txt
+# ====================================================================================
+# Arrays
+# ====================================================================================
+
+# Arrays are incredibly powerful in Ruby. Learn to use them well.
+
+repl do
+  puts "* RUBY PRIMER: ARRAYS"
+end
+
+# ====================================================================================
+# Enumerable ranges and .to_a
+# ====================================================================================
+
+repl do
+  puts "** INFO: Create an array with the numbers 1 to 10."
+  one_to_ten = (1..10).to_a
+  puts one_to_ten
+end
+
+# ====================================================================================
+# Finding elements
+# ====================================================================================
+
+repl do
+  puts "** INFO: Finding elements in an array using ~Array#find_all~."
+  puts "Create a new array that only contains even numbers from the previous array."
+
+  one_to_ten = (1..10).to_a
+  evens = one_to_ten.find_all do |number|
+    number % 2 == 0
+  end
+
+  puts evens
+end
+
+# ====================================================================================
+# Rejecting elements
+# ====================================================================================
+
+repl do
+  puts "** INFO: Removing elements in an array using ~Array#reject~."
+  puts "Create a new array that rejects odd numbers."
+
+  one_to_ten = (1..10).to_a
+  also_even = one_to_ten.reject do |number|
+    number % 2 != 0
+  end
+
+  puts also_even
+end
+
+# ====================================================================================
+# Array transform using the map function.
+# ====================================================================================
+
+repl do
+  puts "** INFO: Creating new derived values from an array using ~Array#map~."
+  puts "Create an array that doubles every number."
+
+  one_to_ten = (1..10).to_a
+  doubled = one_to_ten.map do |number|
+    number * 2
+  end
+
+  puts doubled
+end
+
+# ====================================================================================
+# Combining array functions.
+# ====================================================================================
+
+repl do
+  puts "** INFO: Combining ~Array#find_all~ along with ~Array#map~."
+  puts "Create an array that selects only odd numbers and then multiply those by 10."
+
+  one_to_ten = (1..10).to_a
+  odd_doubled = one_to_ten.find_all do |number|
+    number % 2 != 0
+  end.map do |odd_number|
+    odd_number * 10
+  end
+
+  puts odd_doubled
+end
+
+# ====================================================================================
+# Product function.
+# ====================================================================================
+
+repl do
+  puts "** INFO: Create all combinations of array values using ~Array#product~."
+  puts "All two-item pairs of numbers 1 to 10."
+  one_to_ten = (1..10).to_a
+  all_combinations = one_to_ten.product(one_to_ten)
+  puts all_combinations
+end
+
+# ====================================================================================
+# Uniq and sort function.
+# ====================================================================================
+
+repl do
+  puts "** INFO: Providing uniq values using ~Array#uniq~ and ~Array#sort~."
+  puts "All uniq combinations of numbers regardless of order."
+  puts "For example: [1, 2] is the same as [2, 1]."
+  one_to_ten = (1..10).to_a
+  uniq_combinations =
+    one_to_ten.product(one_to_ten)
+              .map do |unsorted_number|
+                unsorted_number.sort
+              end.uniq
+  puts uniq_combinations
+end
+
+# ====================================================================================
+# Example of an advanced array transform.
+# ====================================================================================
+
+repl do
+  puts "** INFO: Advanced chaining. Combining ~Array's ~map~, ~find_all~, ~sort~, and ~sort_by~."
+  puts "All unique Pythagorean Triples between 1 and 100 sorted by area of the triangle."
+
+  one_to_hundred = (1..100).to_a
+
+  triples =
+    one_to_hundred.product(one_to_hundred).map do |width, height|
+                [width, height, Math.sqrt(width ** 2 + height ** 2)]
+              end.find_all do |_, _, hypotenuse|
+                hypotenuse.to_i == hypotenuse
+              end.map do |triangle|
+                triangle.map(&:to_i)
+              end.uniq do |triangle|
+                triangle.sort
+              end.map do |width, height, hypotenuse|
+                [width, height, hypotenuse, (width * height) / 2]
+              end.sort_by do |_, _, _, area|
+                area
+              end
+
+  triples.each do |width, height, hypotenuse, _|
+    puts "(#{width}, #{height}, #{hypotenuse})"
+  end
+end
+
+# ====================================================================================
+# Example of an sorting.
+# ====================================================================================
+
+repl do
+  puts "** INFO: Implementing a custom sort function that operates on the ~Hash~ datatype."
+
+  things_to_sort = [
+    { type: :background, order: 1 },
+    { type: :foreground, order: 1 },
+    { type: :foreground, order: 2 }
+  ]
+  puts "*** Original array."
+  puts things_to_sort
+
+  puts "*** Simple sort using key."
+  # For a simple sort, you can use sort_by
+  results = things_to_sort.sort_by do |hash|
+    hash[:order]
+  end
+
+  puts results
+
+  puts "*** Custom sort."
+  puts "**** Sorting process."
+  # for a more complicated sort, you can provide a block that returns
+  # -1, 0, 1 for a left and right operand
+  results = things_to_sort.sort do |l, r|
+    sort_result = 0
+    puts "here is l: #{l}"
+    puts "here is r: #{r || "nil"}"
+    # if either value is nil/false return 0
+    if !l || !r
+      sort_result = 0
+    # if the type of "left" is background and the
+    # type of "right" is foreground, then return
+    # -1 (which means "left" is less than "right"
+    elsif l[:type] == :background && r[:type] == :foreground
+      sort_result = -1
+    # if the type of "left" is foreground and the
+    # type of "right" is background, then return
+    #  1 (which means "left" is greater than "right"
+    elsif l[:type] == :foreground && r[:type] == :background
+      sort_result = 1
+    # if "left" and "right"'s type are the same, then
+    # use the order as the tie breaker
+    elsif l[:order] < r[:order]
+      sort_result = -1
+    elsif l[:order] > r[:order]
+      sort_result = 1
+    # returning 0 means both values are equal
+    else
+      sort_result = 0
+    end
+    sort_result
+  end.to_a
+
+  puts "**** Sort result."
+  puts results
+end
+
+# ====================================================================================
+# Api documention for Array that is worth commiting to memory because arrays are so
+# awesome in Ruby: https://docs.ruby-lang.org/en/2.0.0/Array.html
+# ====================================================================================
+
+
+Learn Ruby Optional - Intermediate Ruby Primer - main.rb
+# ./samples/00_learn_ruby_optional/00_intermediate_ruby_primer/app/main.rb
+def tick args
+  args.outputs.labels << [640, 380, "Open repl.rb in the text editor of your choice and follow the document.", 0, 1]
+end
+
+
+Rendering Basics - Labels - main.rb
+# ./samples/01_rendering_basics/01_labels/app/main.rb
+=begin
+
+APIs listing that haven't been encountered in a previous sample apps:
+
+- args.outputs.labels: An array. Values in this array generate labels
+  the screen.
+- args.grid.(left|right|top|bottom): Pixel value for the boundaries of the virtual
+  720 p screen (Dragon Ruby Game Toolkits's virtual resolution is always 1280x720).
+- Numeric#shift_(left|right|up|down): Shifts the Numeric in the correct direction
+  by adding or subracting.
+
+=end
+
+# Labels are used to represent text elements in DragonRuby
+
+# An example of creating a label is:
+# args.outputs.labels << [320, 640, "Example", 3, 1, 255, 0, 0, 200, manaspace.ttf]
+
+# The code above does the following:
+# 1. GET the place where labels go: args.outputs.labels
+# 2. Request a new LABEL be ADDED: <<
+# 3. The DEFINITION of a SOLID is the ARRAY:
+#     [320, 640, "Example", 3,     1,   255,   0,    0,    200,  manaspace.ttf]
+#     [ X ,  Y,    TEXT,   SIZE, ALIGN, RED, GREEN, BLUE, ALPHA, FONT STYLE]
+
+
+# The tick method is called by DragonRuby every frame
+# args contains all the information regarding the game.
+def tick args
+  tick_instructions args, "Sample app shows different version of label sizes and alignments. And how to use hashes instead of arrays."
+  # Here are some examples of simple labels, with the minimum number of parameters
+  # Note that the default values for the other parameters are 0, except for Alpha which is 255 and Font Style which is the default font
+  args.outputs.labels << [400, 620, "Here is a label with just an x, y, and text"]
+
+  args.outputs.labels << [args.grid.left.shift_right(5), args.grid.top.shift_down(5), "This is a label located at the top left."]
+  args.outputs.labels << [args.grid.left.shift_right(5), args.grid.bottom.shift_up(30), "This is a label located at the bottom left."]
+  args.outputs.labels << [args.grid.right.shift_left(420), args.grid.top.shift_down(5), "This is a label located at the top right."]
+  args.outputs.labels << [args.grid.right.shift_left(440), args.grid.bottom.shift_up(30), "This is a label located at the bottom right."]
+
+  # Demonstration of the Size Parameter
+  args.outputs.labels << [175 + 150, 610 - 50, "Smaller label.",  -2]
+  args.outputs.labels << [175 + 150, 580 - 50, "Small label.",    -1]
+  args.outputs.labels << [175 + 150, 550 - 50, "Medium label.",    0]
+  args.outputs.labels << [175 + 150, 520 - 50, "Large label.",     1]
+  args.outputs.labels << [175 + 150, 490 - 50, "Larger label.",    2]
+
+  # Demonstration of the Align Parameter
+  args.outputs.labels << [260 + 150, 345 - 50, "Left aligned.",    0, 2]
+  args.outputs.labels << [260 + 150, 325 - 50, "Center aligned.",  0, 1]
+  args.outputs.labels << [260 + 150, 305 - 50, "Right aligned.",   0, 0]
+
+  # Demonstration of the RGBA parameters
+  args.outputs.labels << [600  + 150, 590 - 50, "Red Label.",       0, 0, 255,   0,   0]
+  args.outputs.labels << [600  + 150, 570 - 50, "Green Label.",     0, 0,   0, 255,   0]
+  args.outputs.labels << [600  + 150, 550 - 50, "Blue Label.",      0, 0,   0,   0, 255]
+  args.outputs.labels << [600  + 150, 530 - 50, "Faded Label.",     0, 0,   0,   0,   0, 128]
+
+  # Demonstration of the Font parameter
+  # In order to use a font of your choice, add its ttf file to the project folder, where the app folder is
+  args.outputs.labels << [690 + 150, 330 - 20, "Custom font (Array)", 0, 1, 125, 0, 200, 255, "manaspc.ttf" ]
+  args.outputs.primitives << { x: 690 + 150,
+                               y: 330 - 50,
+                               text: "Custom font (Hash)",
+                               size_enum: 0,
+                               alignment_enum: 1,
+                               r: 125,
+                               g: 0,
+                               b: 200,
+                               a: 255,
+                               font: "manaspc.ttf" }.label
+
+  # Primitives can hold anything, and can be given a label in the following forms
+  args.outputs.primitives << [690 + 150, 330 - 80, "Custom font (.primitives Array)", 0, 1, 125, 0, 200, 255, "manaspc.ttf" ].label
+
+  args.outputs.primitives << { x: 690 + 150,
+                               y: 330 - 110,
+                               text: "Custom font (.primitives Hash)",
+                               size_enum: 0,
+                               alignment_enum: 1,
+                               r: 125,
+                               g: 0,
+                               b: 200,
+                               a: 255,
+                               font: "manaspc.ttf" }.label
+end
+
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
+  end
+
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+end
+
+
+Rendering Basics - Lines - main.rb
+# ./samples/01_rendering_basics/02_lines/app/main.rb
+=begin
+
+APIs listing that haven't been encountered in a previous sample apps:
+
+- args.outputs.lines: An array. Values in this array generate lines on
+  the screen.
+- args.state.tick_count: This property contains an integer value that
+  represents the current frame. GTK renders at 60 FPS. A value of 0
+  for args.state.tick_count represents the initial load of the game.
+
+=end
+
+# The parameters required for lines are:
+# 1. The initial point (x, y)
+# 2. The end point (x2, y2)
+# 3. The rgba values for the color and transparency (r, g, b, a)
+
+# An example of creating a line would be:
+# args.outputs.lines << [100, 100, 300, 300, 255, 0, 255, 255]
+
+# This would create a line from (100, 100) to (300, 300)
+# The RGB code (255, 0, 255) would determine its color, a purple
+# It would have an Alpha value of 255, making it completely opaque
+
+def tick args
+  tick_instructions args, "Sample app shows how to create lines."
+
+  args.outputs.labels << [480, 620, "Lines (x, y, x2, y2, r, g, b, a)"]
+
+  # Some simple lines
+  args.outputs.lines  << [380, 450, 675, 450]
+  args.outputs.lines  << [380, 410, 875, 410]
+
+  # These examples utilize args.state.tick_count to change the length of the lines over time
+  # args.state.tick_count is the ticks that have occurred in the game
+  # This is accomplished by making either the starting or ending point based on the args.state.tick_count
+  args.outputs.lines  << [380, 370, 875, 370, args.state.tick_count % 255, 0, 0, 255]
+  args.outputs.lines  << [380, 330 - args.state.tick_count % 25, 875, 330, 0, 0, 0, 255]
+  args.outputs.lines  << [380 + args.state.tick_count % 400, 290, 875, 290, 0, 0, 0, 255]
+end
+
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
+  end
+
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+end
+
+
+Rendering Basics - Solids Borders - main.rb
+# ./samples/01_rendering_basics/03_solids_borders/app/main.rb
+=begin
+
+APIs listing that haven't been encountered in a previous sample apps:
+
+- args.outputs.solids: An array. Values in this array generate
+  solid/filled rectangles on the screen.
+
+=end
+
+# Rects are outputted in DragonRuby as rectangles
+# If filled in, they are solids
+# If hollow, they are borders
+
+# Solids are added to args.outputs.solids
+# Borders are added to args.outputs.borders
+
+# The parameters required for rects are:
+# 1. The upper right corner (x, y)
+# 2. The width (w)
+# 3. The height (h)
+# 4. The rgba values for the color and transparency (r, g, b, a)
+
+# Here is an example of a rect definition:
+# [100, 100, 400, 500, 0, 255, 0, 180]
+
+# The example would create a rect from (100, 100)
+# Extending 400 pixels across the x axis
+# and 500 pixels across the y axis
+# The rect would be green (0, 255, 0)
+# and mostly opaque with some transparency (180)
+
+# Whether the rect would be filled or not depends on if
+# it is added to args.outputs.solids or args.outputs.borders
+
+
+def tick args
+  tick_instructions args, "Sample app shows how to create solid squares."
+  args.outputs.labels << [460, 600, "Solids (x, y, w, h, r, g, b, a)"]
+  args.outputs.solids << [470, 520, 50, 50]
+  args.outputs.solids << [530, 520, 50, 50, 0, 0, 0]
+  args.outputs.solids << [590, 520, 50, 50, 255, 0, 0]
+  args.outputs.solids << [650, 520, 50, 50, 255, 0, 0, 128]
+  args.outputs.solids << [710, 520, 50, 50, 0, 0, 0, 128 + args.state.tick_count % 128]
+
+
+  args.outputs.labels <<  [460, 400, "Borders (x, y, w, h, r, g, b, a)"]
+  args.outputs.borders << [470, 320, 50, 50]
+  args.outputs.borders << [530, 320, 50, 50, 0, 0, 0]
+  args.outputs.borders << [590, 320, 50, 50, 255, 0, 0]
+  args.outputs.borders << [650, 320, 50, 50, 255, 0, 0, 128]
+  args.outputs.borders << [710, 320, 50, 50, 0, 0, 0, 128 + args.state.tick_count % 128]
+end
+
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
+  end
+
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+end
+
+
+Rendering Basics - Sprites - main.rb
+# ./samples/01_rendering_basics/04_sprites/app/main.rb
+=begin
+
+APIs listing that haven't been encountered in a previous sample apps:
+
+- args.outputs.sprites: An array. Values in this array generate
+  sprites on the screen. The location of the sprite is assumed to
+  be under the mygame/ directory (the exception being dragonruby.png).
+
+=end
+
+
+# For all other display outputs, Sprites are your solution
+# Sprites import images and display them with a certain rectangular area
+# The image can be of any usual format and should be located within the folder,
+# similar to additional fonts.
+
+# Sprites have the following parameters
+# Rectangular area (x, y, width, height)
+# The image (path)
+# Rotation (angle)
+# Alpha (a)
+
+def tick args
+  tick_instructions args, "Sample app shows how to render a sprite. Set its alpha, and rotate it."
+  args.outputs.labels <<  [460, 600, "Sprites (x, y, w, h, path, angle, a)"]
+  args.outputs.sprites << [460, 470, 128, 101, 'dragonruby.png']
+  args.outputs.sprites << [610, 470, 128, 101, 'dragonruby.png', args.state.tick_count % 360]
+  args.outputs.sprites << [760, 470, 128, 101, 'dragonruby.png', 0, args.state.tick_count % 255]
+end
+
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
+  end
+
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+end
+
+
+Rendering Basics - Sounds - main.rb
+# ./samples/01_rendering_basics/05_sounds/app/main.rb
+=begin
+
+ APIs Listing that haven't been encountered in previous sample apps:
+
+ - sample: Chooses random element from array.
+   In this sample app, the target note is set by taking a sample from the collection
+   of available notes.
+
+ Reminders:
+
+ - String interpolation: Uses #{} syntax; everything between the #{ and the } is evaluated
+   as Ruby code, and the placeholder is replaced with its corresponding value or result.
+
+ - args.outputs.labels: An array. The values generate a label.
+   The parameters are [X, Y, TEXT, SIZE, ALIGNMENT, RED, GREEN, BLUE, ALPHA, FONT STYLE]
+   For more information about labels, go to mygame/documentation/02-labels.md.
+=end
+
+# This sample app allows users to test their musical skills by matching the piano sound that plays in each
+# level to the correct note.
+
+# Runs all the methods necessary for the game to function properly.
+def tick args
+  args.outputs.labels << [640, 360, "Click anywhere to play a random sound.", 0, 1]
+  args.state.notes ||= [:C3, :D3, :E3, :F3, :G3, :A3, :B3, :C4]
+
+  if args.inputs.mouse.click
+    # Play a sound by adding a string to args.outputs.sounds
+    args.outputs.sounds << "sounds/#{args.state.notes.sample}.wav" # sound of target note is output
+  end
+end
+
+
+Rendering Basics - Audio Mixer - main.rb
+# ./samples/01_rendering_basics/06_audio_mixer/app/main.rb
+$gtk.reset
+
+$boxsize = 30
+
+def render_sources args
+  mouse_in_panel = (args.state.selected != 0) && args.inputs.mouse.position.inside_rect?([900, 450, 340, 250])
+  mouse_new_down = (args.state.mouse_held == 1)
+
+  if (mouse_new_down && !mouse_in_panel)
+    args.state.selected = 0  # will reset below if we hit something.
+  end
+
+  args.audio.keys.each { |k|
+    s = args.audio[k]
+
+    if (mouse_new_down) && !mouse_in_panel && args.inputs.mouse.position.inside_rect?([s[:screenx], s[:screeny], $boxsize, $boxsize])
+      args.state.selected = k
+      args.state.dragging_source = true
+    end
+
+    isselected = (k == args.state.selected)
+
+    if isselected && args.state.dragging_source
+      # you can hang anything on the audio hashes you want, so we store the
+      #  actual screen position so it doesn't scale weirdly vs your mouse.
+      s[:screenx] = args.inputs.mouse.x - ($boxsize / 2)
+      s[:screeny] = args.inputs.mouse.y - ($boxsize / 2)
+
+      s[:screeny] = 50 if s[:screeny] < 50
+      s[:screeny] = (719 - $boxsize) if s[:screeny] > (719 - $boxsize)
+      s[:screenx] = 0 if s[:screenx] < 0
+      s[:screenx] = (1279 - $boxsize) if s[:screenx] > (1279 - $boxsize)
+
+      s[:x] = ((s[:screenx] / 1279.0) * 2.0) - 1.0  # scale to -1.0 - 1.0 range
+      s[:y] = ((s[:screeny] / 719.0) * 2.0) - 1.0   # scale to -1.0 - 1.0 range
+    end
+
+    color = isselected ? [ 0, 255, 0, 255 ] : [ 0, 0, 255, 255 ]
+    args.outputs.primitives << [s[:screenx], s[:screeny], $boxsize, $boxsize, *color].solid
+  }
+end
+
+def render_panel args
+  s = args.audio[args.state.selected]
+  return if s.nil?
+  mouse_down = (args.state.mouse_held > 0)
+
+  args.outputs.primitives << [900, 450, 340, 250, 127, 127, 200, 255].solid
+  args.outputs.primitives << [1075, 690, "Source ##{args.state.selected}", 3, 1, 255, 255, 255].label
+  args.outputs.primitives << [910, 660, 1230, 660, 255, 255, 255].line
+  args.outputs.primitives << [910, 650, "screen:    (#{s[:screenx].to_i}, #{s[:screeny].to_i})", 0, 0, 255, 255, 255].label
+  args.outputs.primitives << [910, 625, "position:  (#{s[:x].round(5).to_s[0..6]}, #{s[:y].round(5).to_s[0..6]})", 0, 0, 255, 255, 255].label
+
+  slider = [1022, 586, 200, 7]
+  if mouse_down && args.inputs.mouse.position.inside_rect?(slider)
+    s[:pitch] = ((args.inputs.mouse.x - slider[0]).to_f / (slider[2]-1.0)) * 2.0
+  end
+  slidercolor = (s[:pitch] / 2.0) * 255
+  args.outputs.primitives << [*slider, slidercolor, slidercolor, slidercolor, 255].solid
+  args.outputs.primitives << [910, 600, "pitch: #{s[:pitch].round(3).to_s[0..2]}", 0, 0, 255, 255, 255].label
+
+  slider = [1022, 561, 200, 7]
+  if mouse_down && args.inputs.mouse.position.inside_rect?(slider)
+    s[:gain] = (args.inputs.mouse.x - slider[0]).to_f / (slider[2]-1.0)
+  end
+  slidercolor = s[:gain] * 255
+  args.outputs.primitives << [*slider, slidercolor, slidercolor, slidercolor, 255].solid
+  args.outputs.primitives << [910, 575, "gain: #{s[:gain].round(3).to_s[0..2]}", 0, 0, 255, 255, 255].label
+
+  checkbox = [1022, 533, 10, 12]
+  if (args.state.mouse_held == 1) && args.inputs.mouse.position.inside_rect?(checkbox)
+    s[:looping] = !s[:looping]
+  end
+  checkboxcolor = s[:looping] ? 255 : 0
+  args.outputs.primitives << [*checkbox, checkboxcolor, checkboxcolor, checkboxcolor, 255].solid
+  args.outputs.primitives << [910, 550, "looping:", 0, 0, 255, 255, 255].label
+
+  checkbox = [1022, 508, 10, 12]
+  if (args.state.mouse_held == 1) && args.inputs.mouse.position.inside_rect?(checkbox)
+    s[:paused] = !s[:paused]
+  end
+  checkboxcolor = s[:paused] ? 255 : 0
+  args.outputs.primitives << [*checkbox, checkboxcolor, checkboxcolor, checkboxcolor, 255].solid
+  args.outputs.primitives << [910, 525, "paused:", 0, 0, 255, 255, 255].label
+
+  button = [910, 460, 320, 20]
+  if (args.state.mouse_held == 1) && args.inputs.mouse.position.inside_rect?(button)
+    args.audio.delete(args.state.selected)
+    args.state.selected = 0
+  end
+  args.outputs.primitives << [*button, 255, 0, 0, 255].solid
+  args.outputs.primitives << [button[0] + (button[2] / 2), button[1]+20, "DELETE SOURCE", 0, 1, 255, 255, 0].label
+end
+
+def spawn_new_sound args, num
+  input = nil
+  input = "sounds/#{num}.#{(num == 6) ? 'ogg' : 'wav'}"
+
+  # Spawn randomly in an area that won't be covered by UI.
+  screenx = (rand * 600.0) + 200.0
+  screeny = (rand * 400.0) + 100.0
+
+  args.state.next_sound_index += 1
+
+  # you can hang anything on the audio hashes you want, so we store the
+  #  actual screen position in here for convenience.
+  args.audio[args.state.next_sound_index] = {
+    input: input,
+    screenx: screenx,
+    screeny: screeny,
+    x: ((screenx / 1279.0) * 2.0) - 1.0,  # scale to -1.0 - 1.0 range
+    y: ((screeny / 719.0) * 2.0) - 1.0,   # scale to -1.0 - 1.0 range
+    z: 0.0,
+    gain: 1.0,
+    pitch: 1.0,
+    looping: true,
+    paused: false
+  }
+
+  args.state.selected = args.state.next_sound_index
+end
+
+def render_launcher args
+  total = 6
+  x = (1280 - (total * $boxsize * 3)) / 2
+  y = 10
+  args.outputs.primitives << [0, 0, 1280, ((y*2) + $boxsize), 127, 127, 127, 255].solid
+  for i in 1..total
+    args.outputs.primitives << [x, y, $boxsize, $boxsize, 255, 255, 255, 255].solid
+    args.outputs.primitives << [x+8, y+28, i.to_s, 3, 0, 0, 0, 255, 255].label
+    if args.inputs.mouse.click && args.inputs.mouse.click.point.inside_rect?([x, y, $boxsize, $boxsize])
+      spawn_new_sound args, i
+    end
+    x = x + ($boxsize * 3)
+  end
+end
+
+def render_ui args
+  render_launcher args
+  render_panel args
+end
+
+def tick args
+  args.state.mouse_held ||= 0
+  args.state.dragging_source ||= false
+  args.state.selected ||= 0
+  args.state.next_sound_index ||= 0
+
+  if args.inputs.mouse.up
+    args.state.mouse_held = 0
+    args.state.dragging_source = false
+  elsif args.inputs.mouse.down || (args.state.mouse_held > 0)
+    args.state.mouse_held += 1
+  else
+  end
+
+  args.outputs.background_color = [ 0, 0, 0, 255 ]
+  render_sources args
+  render_ui args
+end
+
+
+Rendering Basics - Sound Synthesis - main.rb
+# ./samples/01_rendering_basics/07_sound_synthesis/app/main.rb
+begin # region: top level tick methods
+  def tick args
+    defaults args
+    render args
+    input args
+    process_audio_queue args
+  end
+
+  def defaults args
+    args.state.sine_waves      ||= {}
+    args.state.square_waves    ||= {}
+    args.state.saw_tooth_waves ||= {}
+    args.state.triangle_waves  ||= {}
+    args.state.audio_queue     ||= []
+    args.state.buttons         ||= [
+      (frequency_buttons args),
+      (sine_wave_note_buttons args),
+      (bell_buttons args),
+      (square_wave_note_buttons args),
+      (saw_tooth_wave_note_buttons args),
+      (triangle_wave_note_buttons args),
+    ].flatten
+  end
+
+  def render args
+    args.outputs.borders << args.state.buttons.map { |b| b[:border] }
+    args.outputs.labels  << args.state.buttons.map { |b| b[:label]  }
+    args.outputs.labels  << args.layout
+                              .rect(row: 0, col: 11.5)
+                              .yield_self { |r| r.merge y: r.y + r.h }
+                              .merge(text: "This is a Pro only feature. Click here to watch the YouTube video if you are on the Standard License.",
+                                     alignment_enum: 1)
+  end
+
+
+  def input args
+    args.state.buttons.each do |b|
+      if args.inputs.mouse.click && (args.inputs.mouse.click.inside_rect? b[:rect])
+        parameter_string = (b.slice :frequency, :note, :octave).map { |k, v| "#{k}: #{v}" }.join ", "
+        args.gtk.notify! "#{b[:method_to_call]} #{parameter_string}"
+        send b[:method_to_call], args, b
+      end
+    end
+
+    if args.inputs.mouse.click && (args.inputs.mouse.click.inside_rect? (args.layout.rect(row: 0).yield_self { |r| r.merge y: r.y + r.h.half, h: r.h.half }))
+      args.gtk.openurl 'https://www.youtube.com/watch?v=zEzovM5jT-k&ab_channel=AmirRajan'
+    end
+  end
+
+  def process_audio_queue args
+    to_queue = args.state.audio_queue.find_all { |v| v[:queue_at] <= args.tick_count }
+    args.state.audio_queue -= to_queue
+    to_queue.each { |a| args.audio[a[:id]] = a }
+
+    args.audio.find_all { |k, v| v[:decay_rate] }
+      .each     { |k, v| v[:gain] -= v[:decay_rate] }
+
+    sounds_to_stop = args.audio
+                       .find_all { |k, v| v[:stop_at] && args.state.tick_count >= v[:stop_at] }
+                       .map { |k, v| k }
+
+    sounds_to_stop.each { |k| args.audio.delete k }
+  end
+end
+
+begin # region: button definitions, ui layout, callback functions
+  def button args, opts
+    button_def = opts.merge rect: (args.layout.rect (opts.merge w: 2, h: 1))
+
+    button_def[:border] = button_def[:rect].merge r: 0, g: 0, b: 0
+
+    label_offset_x = 5
+    label_offset_y = 30
+
+    button_def[:label]  = button_def[:rect].merge text: opts[:text],
+                                                  size_enum: -2.5,
+                                                  x: button_def[:rect].x + label_offset_x,
+                                                  y: button_def[:rect].y + label_offset_y
+
+    button_def
+  end
+
+  def play_sine_wave args, sender
+    queue_sine_wave args,
+                    frequency: sender[:frequency],
+                    duration: 1.seconds,
+                    fade_out: true
+  end
+
+  def play_note args, sender
+    method_to_call = :queue_sine_wave
+    method_to_call = :queue_square_wave    if sender[:type] == :square
+    method_to_call = :queue_saw_tooth_wave if sender[:type] == :saw_tooth
+    method_to_call = :queue_triangle_wave  if sender[:type] == :triangle
+    method_to_call = :queue_bell           if sender[:type] == :bell
+
+    send method_to_call, args,
+         frequency: (frequency_for note: sender[:note], octave: sender[:octave]),
+         duration: 1.seconds,
+         fade_out: true
+  end
+
+  def frequency_buttons args
+    [
+      (button args,
+              row: 4.0, col: 0, text: "300hz",
+              frequency: 300,
+              method_to_call: :play_sine_wave),
+      (button args,
+              row: 5.0, col: 0, text: "400hz",
+              frequency: 400,
+              method_to_call: :play_sine_wave),
+      (button args,
+              row: 6.0, col: 0, text: "500hz",
+              frequency: 500,
+              method_to_call: :play_sine_wave),
+    ]
+  end
+
+  def sine_wave_note_buttons args
+    [
+      (button args,
+              row: 1.5, col: 2, text: "Sine C4",
+              note: :c, octave: 4, type: :sine, method_to_call: :play_note),
+      (button args,
+              row: 2.5, col: 2, text: "Sine D4",
+              note: :d, octave: 4, type: :sine, method_to_call: :play_note),
+      (button args,
+              row: 3.5, col: 2, text: "Sine E4",
+              note: :e, octave: 4, type: :sine, method_to_call: :play_note),
+      (button args,
+              row: 4.5, col: 2, text: "Sine F4",
+              note: :f, octave: 4, type: :sine, method_to_call: :play_note),
+      (button args,
+              row: 5.5, col: 2, text: "Sine G4",
+              note: :g, octave: 4, type: :sine, method_to_call: :play_note),
+      (button args,
+              row: 6.5, col: 2, text: "Sine A5",
+              note: :a, octave: 5, type: :sine, method_to_call: :play_note),
+      (button args,
+              row: 7.5, col: 2, text: "Sine B5",
+              note: :b, octave: 5, type: :sine, method_to_call: :play_note),
+      (button args,
+              row: 8.5, col: 2, text: "Sine C5",
+              note: :c, octave: 5, type: :sine, method_to_call: :play_note),
+    ]
+  end
+
+  def square_wave_note_buttons args
+    [
+      (button args,
+              row: 1.5, col: 6, text: "Square C4",
+              note: :c, octave: 4, type: :square, method_to_call: :play_note),
+      (button args,
+              row: 2.5, col: 6, text: "Square D4",
+              note: :d, octave: 4, type: :square, method_to_call: :play_note),
+      (button args,
+              row: 3.5, col: 6, text: "Square E4",
+              note: :e, octave: 4, type: :square, method_to_call: :play_note),
+      (button args,
+              row: 4.5, col: 6, text: "Square F4",
+              note: :f, octave: 4, type: :square, method_to_call: :play_note),
+      (button args,
+              row: 5.5, col: 6, text: "Square G4",
+              note: :g, octave: 4, type: :square, method_to_call: :play_note),
+      (button args,
+              row: 6.5, col: 6, text: "Square A5",
+              note: :a, octave: 5, type: :square, method_to_call: :play_note),
+      (button args,
+              row: 7.5, col: 6, text: "Square B5",
+              note: :b, octave: 5, type: :square, method_to_call: :play_note),
+      (button args,
+              row: 8.5, col: 6, text: "Square C5",
+              note: :c, octave: 5, type: :square, method_to_call: :play_note),
+    ]
+  end
+  def saw_tooth_wave_note_buttons args
+    [
+      (button args,
+              row: 1.5, col: 8, text: "Saw C4",
+              note: :c, octave: 4, type: :saw_tooth, method_to_call: :play_note),
+      (button args,
+              row: 2.5, col: 8, text: "Saw D4",
+              note: :d, octave: 4, type: :saw_tooth, method_to_call: :play_note),
+      (button args,
+              row: 3.5, col: 8, text: "Saw E4",
+              note: :e, octave: 4, type: :saw_tooth, method_to_call: :play_note),
+      (button args,
+              row: 4.5, col: 8, text: "Saw F4",
+              note: :f, octave: 4, type: :saw_tooth, method_to_call: :play_note),
+      (button args,
+              row: 5.5, col: 8, text: "Saw G4",
+              note: :g, octave: 4, type: :saw_tooth, method_to_call: :play_note),
+      (button args,
+              row: 6.5, col: 8, text: "Saw A5",
+              note: :a, octave: 5, type: :saw_tooth, method_to_call: :play_note),
+      (button args,
+              row: 7.5, col: 8, text: "Saw B5",
+              note: :b, octave: 5, type: :saw_tooth, method_to_call: :play_note),
+      (button args,
+              row: 8.5, col: 8, text: "Saw C5",
+              note: :c, octave: 5, type: :saw_tooth, method_to_call: :play_note),
+    ]
+  end
+
+  def triangle_wave_note_buttons args
+    [
+      (button args,
+              row: 1.5, col: 10, text: "Triangle C4",
+              note: :c, octave: 4, type: :triangle, method_to_call: :play_note),
+      (button args,
+              row: 2.5, col: 10, text: "Triangle D4",
+              note: :d, octave: 4, type: :triangle, method_to_call: :play_note),
+      (button args,
+              row: 3.5, col: 10, text: "Triangle E4",
+              note: :e, octave: 4, type: :triangle, method_to_call: :play_note),
+      (button args,
+              row: 4.5, col: 10, text: "Triangle F4",
+              note: :f, octave: 4, type: :triangle, method_to_call: :play_note),
+      (button args,
+              row: 5.5, col: 10, text: "Triangle G4",
+              note: :g, octave: 4, type: :triangle, method_to_call: :play_note),
+      (button args,
+              row: 6.5, col: 10, text: "Triangle A5",
+              note: :a, octave: 5, type: :triangle, method_to_call: :play_note),
+      (button args,
+              row: 7.5, col: 10, text: "Triangle B5",
+              note: :b, octave: 5, type: :triangle, method_to_call: :play_note),
+      (button args,
+              row: 8.5, col: 10, text: "Triangle C5",
+              note: :c, octave: 5, type: :triangle, method_to_call: :play_note),
+    ]
+  end
+
+  def bell_buttons args
+    [
+      (button args,
+              row: 1.5, col: 4, text: "Bell C4",
+              note: :c, octave: 4, type: :bell, method_to_call: :play_note),
+      (button args,
+              row: 2.5, col: 4, text: "Bell D4",
+              note: :d, octave: 4, type: :bell, method_to_call: :play_note),
+      (button args,
+              row: 3.5, col: 4, text: "Bell E4",
+              note: :e, octave: 4, type: :bell, method_to_call: :play_note),
+      (button args,
+              row: 4.5, col: 4, text: "Bell F4",
+              note: :f, octave: 4, type: :bell, method_to_call: :play_note),
+      (button args,
+              row: 5.5, col: 4, text: "Bell G4",
+              note: :g, octave: 4, type: :bell, method_to_call: :play_note),
+      (button args,
+              row: 6.5, col: 4, text: "Bell A5",
+              note: :a, octave: 5, type: :bell, method_to_call: :play_note),
+      (button args,
+              row: 7.5, col: 4, text: "Bell B5",
+              note: :b, octave: 5, type: :bell, method_to_call: :play_note),
+      (button args,
+              row: 8.5, col: 4, text: "Bell C5",
+              note: :c, octave: 5, type: :bell, method_to_call: :play_note),
+    ]
+  end
+end
+
+begin # region: wave generation
+  begin # sine wave
+    def defaults_sine_wave_for
+      { frequency: 440, sample_rate: 48000 }
+    end
+
+    def sine_wave_for opts = {}
+      opts = defaults_sine_wave_for.merge opts
+      frequency   = opts[:frequency]
+      sample_rate = opts[:sample_rate]
+      period_size = (sample_rate.fdiv frequency).ceil
+      period_size.map_with_index do |i|
+        Math::sin((2.0 * Math::PI) / (sample_rate.to_f / frequency.to_f) * i)
+      end.to_a
+    end
+
+    def defaults_queue_sine_wave
+      { frequency: 440, duration: 60, gain: 1.0, fade_out: false, queue_in: 0 }
+    end
+
+    def queue_sine_wave args, opts = {}
+      opts        = defaults_queue_sine_wave.merge opts
+      frequency   = opts[:frequency]
+      sample_rate = 48000
+
+      sine_wave = sine_wave_for frequency: frequency, sample_rate: sample_rate
+      args.state.sine_waves[frequency] ||= sine_wave_for frequency: frequency, sample_rate: sample_rate
+
+      proc = lambda do
+        generate_audio_data args.state.sine_waves[frequency], sample_rate
+      end
+
+      audio_state = new_audio_state args, opts
+      audio_state[:input] = [1, sample_rate, proc]
+      queue_audio args, audio_state: audio_state, wave: sine_wave
+    end
+  end
+
+  begin # region: square wave
+    def defaults_square_wave_for
+      { frequency: 440, sample_rate: 48000 }
+    end
+
+    def square_wave_for opts = {}
+      opts = defaults_square_wave_for.merge opts
+      sine_wave = sine_wave_for opts
+      sine_wave.map do |v|
+        if v >= 0
+          1.0
+        else
+          -1.0
+        end
+      end.to_a
+    end
+
+    def defaults_queue_square_wave
+      { frequency: 440, duration: 60, gain: 0.3, fade_out: false, queue_in: 0 }
+    end
+
+    def queue_square_wave args, opts = {}
+      opts        = defaults_queue_square_wave.merge opts
+      frequency   = opts[:frequency]
+      sample_rate = 48000
+
+      square_wave = square_wave_for frequency: frequency, sample_rate: sample_rate
+      args.state.square_waves[frequency] ||= square_wave_for frequency: frequency, sample_rate: sample_rate
+
+      proc = lambda do
+        generate_audio_data args.state.square_waves[frequency], sample_rate
+      end
+
+      audio_state = new_audio_state args, opts
+      audio_state[:input] = [1, sample_rate, proc]
+      queue_audio args, audio_state: audio_state, wave: square_wave
+    end
+  end
+
+  begin # region: saw tooth wave
+    def defaults_saw_tooth_wave_for
+      { frequency: 440, sample_rate: 48000 }
+    end
+
+    def saw_tooth_wave_for opts = {}
+      opts = defaults_saw_tooth_wave_for.merge opts
+      sine_wave = sine_wave_for opts
+      period_size = sine_wave.length
+      sine_wave.map_with_index do |v, i|
+        (((i % period_size).fdiv period_size) * 2) - 1
+      end
+    end
+
+    def defaults_queue_saw_tooth_wave
+      { frequency: 440, duration: 60, gain: 0.3, fade_out: false, queue_in: 0 }
+    end
+
+    def queue_saw_tooth_wave args, opts = {}
+      opts        = defaults_queue_saw_tooth_wave.merge opts
+      frequency   = opts[:frequency]
+      sample_rate = 48000
+
+      saw_tooth_wave = saw_tooth_wave_for frequency: frequency, sample_rate: sample_rate
+      args.state.saw_tooth_waves[frequency] ||= saw_tooth_wave_for frequency: frequency, sample_rate: sample_rate
+
+      proc = lambda do
+        generate_audio_data args.state.saw_tooth_waves[frequency], sample_rate
+      end
+
+      audio_state = new_audio_state args, opts
+      audio_state[:input] = [1, sample_rate, proc]
+      queue_audio args, audio_state: audio_state, wave: saw_tooth_wave
+    end
+  end
+
+  begin # region: triangle wave
+    def defaults_triangle_wave_for
+      { frequency: 440, sample_rate: 48000 }
+    end
+
+    def triangle_wave_for opts = {}
+      opts = defaults_saw_tooth_wave_for.merge opts
+      sine_wave = sine_wave_for opts
+      period_size = sine_wave.length
+      sine_wave.map_with_index do |v, i|
+        ratio = (i.fdiv period_size)
+        if ratio <= 0.5
+          (ratio * 4) - 1
+        else
+          ratio -= 0.5
+          1 - (ratio * 4)
+        end
+      end
+    end
+
+    def defaults_queue_triangle_wave
+      { frequency: 440, duration: 60, gain: 1.0, fade_out: false, queue_in: 0 }
+    end
+
+    def queue_triangle_wave args, opts = {}
+      opts        = defaults_queue_triangle_wave.merge opts
+      frequency   = opts[:frequency]
+      sample_rate = 48000
+
+      triangle_wave = triangle_wave_for frequency: frequency, sample_rate: sample_rate
+      args.state.triangle_waves[frequency] ||= triangle_wave_for frequency: frequency, sample_rate: sample_rate
+
+      proc = lambda do
+        generate_audio_data args.state.triangle_waves[frequency], sample_rate
+      end
+
+      audio_state = new_audio_state args, opts
+      audio_state[:input] = [1, sample_rate, proc]
+      queue_audio args, audio_state: audio_state, wave: triangle_wave
+    end
+  end
+
+  begin # region: bell
+    def defaults_queue_bell
+      { frequency: 440, duration: 1.seconds, queue_in: 0 }
+    end
+
+    def queue_bell args, opts = {}
+      (bell_to_sine_waves (defaults_queue_bell.merge opts)).each { |b| queue_sine_wave args, b }
+    end
+
+    def bell_harmonics
+      [
+        { frequency_ratio: 0.5, duration_ratio: 1.00 },
+        { frequency_ratio: 1.0, duration_ratio: 0.80 },
+        { frequency_ratio: 2.0, duration_ratio: 0.60 },
+        { frequency_ratio: 3.0, duration_ratio: 0.40 },
+        { frequency_ratio: 4.2, duration_ratio: 0.25 },
+        { frequency_ratio: 5.4, duration_ratio: 0.20 },
+        { frequency_ratio: 6.8, duration_ratio: 0.15 }
+      ]
+    end
+
+    def defaults_bell_to_sine_waves
+      { frequency: 440, duration: 1.seconds, queue_in: 0 }
+    end
+
+    def bell_to_sine_waves opts = {}
+      opts = defaults_bell_to_sine_waves.merge opts
+      bell_harmonics.map do |b|
+        {
+          frequency: opts[:frequency] * b[:frequency_ratio],
+          duration:  opts[:duration] * b[:duration_ratio],
+          queue_in:  opts[:queue_in],
+          gain:      (1.fdiv bell_harmonics.length),
+          fade_out:  true
+        }
+      end
+    end
+  end
+
+  begin # audio entity construction
+    def generate_audio_data sine_wave, sample_rate
+      sample_size = (sample_rate.fdiv (1000.fdiv 60)).ceil
+      copy_count  = (sample_size.fdiv sine_wave.length).ceil
+      sine_wave * copy_count
+    end
+
+    def defaults_new_audio_state
+      { frequency: 440, duration: 60, gain: 1.0, fade_out: false, queue_in: 0 }
+    end
+
+    def new_audio_state args, opts = {}
+      opts        = defaults_new_audio_state.merge opts
+      decay_rate  = 0
+      decay_rate  = 1.fdiv(opts[:duration]) * opts[:gain] if opts[:fade_out]
+      frequency   = opts[:frequency]
+      sample_rate = 48000
+
+      {
+        id:               (new_id! args),
+        frequency:        frequency,
+        sample_rate:      48000,
+        stop_at:          args.tick_count + opts[:queue_in] + opts[:duration],
+        gain:             opts[:gain].to_f,
+        queue_at:         args.state.tick_count + opts[:queue_in],
+        decay_rate:       decay_rate,
+        pitch:            1.0,
+        looping:          true,
+        paused:           false
+      }
+    end
+
+    def queue_audio args, opts = {}
+      graph_wave args, opts[:wave], opts[:audio_state][:frequency]
+      args.state.audio_queue << opts[:audio_state]
+    end
+
+    def new_id! args
+      args.state.audio_id ||= 0
+      args.state.audio_id  += 1
+    end
+
+    def graph_wave args, wave, frequency
+      if args.state.tick_count != args.state.graphed_at
+        args.outputs.static_lines.clear
+        args.outputs.static_sprites.clear
+      end
+
+      wave = wave
+
+      r, g, b = frequency.to_i % 85,
+                frequency.to_i % 170,
+                frequency.to_i % 255
+
+      starting_rect = args.layout.rect(row: 5, col: 13)
+      x_scale    = 10
+      y_scale    = 100
+      max_points = 25
+
+      points = wave
+      if wave.length > max_points
+        resolution = wave.length.idiv max_points
+        points = wave.find_all.with_index { |y, i| (i % resolution == 0) }
+      end
+
+      args.outputs.static_lines << points.map_with_index do |y, x|
+        next_y = points[x + 1]
+
+        if next_y
+          {
+            x:  starting_rect.x + (x * x_scale),
+            y:  starting_rect.y + starting_rect.h.half + y_scale * y,
+            x2: starting_rect.x + ((x + 1) * x_scale),
+            y2: starting_rect.y + starting_rect.h.half + y_scale * next_y,
+            r:  r,
+            g:  g,
+            b:  b
+          }
+        end
+      end
+
+      args.outputs.static_sprites << points.map_with_index do |y, x|
+        {
+          x:  (starting_rect.x + (x * x_scale)) - 2,
+          y:  (starting_rect.y + starting_rect.h.half + y_scale * y) - 2,
+          w:  4,
+          h:  4,
+          path: 'sprites/square-white.png',
+          r: r,
+          g: g,
+          b: b
+        }
+      end
+
+      args.state.graphed_at = args.state.tick_count
+    end
+  end
+
+  begin # region: musical note mapping
+    def defaults_frequency_for
+      { note: :a, octave: 5, sharp:  false, flat:   false }
+    end
+
+    def frequency_for opts = {}
+      opts = defaults_frequency_for.merge opts
+      octave_offset_multiplier  = opts[:octave] - 5
+      note = note_frequencies_octave_5[opts[:note]]
+      if octave_offset_multiplier < 0
+        note = note * 1 / (octave_offset_multiplier.abs + 1)
+      elsif octave_offset_multiplier > 0
+        note = note * (octave_offset_multiplier.abs + 1) / 1
+      end
+      note
+    end
+
+    def note_frequencies_octave_5
+      {
+        a: 440.0,
+        a_sharp: 466.16, b_flat: 466.16,
+        b: 493.88,
+        c: 523.25,
+        c_sharp: 554.37, d_flat: 587.33,
+        d: 587.33,
+        d_sharp: 622.25, e_flat: 659.25,
+        e: 659.25,
+        f: 698.25,
+        f_sharp: 739.99, g_flat: 739.99,
+        g: 783.99,
+        g_sharp: 830.61, a_flat: 830.61
+      }
+    end
+  end
+end
+
+$gtk.reset
+
+
+Input Basics - Keyboard - main.rb
+# ./samples/02_input_basics/01_keyboard/app/main.rb
+=begin
+
+APIs listing that haven't been encountered in a previous sample apps:
+
+- args.inputs.keyboard.key_up.KEY: The value of the properties will be set
+  to the frame  that the key_up event occurred (the frame correlates
+  to args.state.tick_count). Otherwise the value will be nil. For a
+  full listing of keys, take a look at mygame/documentation/06-keyboard.md.
+- args.state.PROPERTY: The state property on args is a dynamic
+  structure. You can define ANY property here with ANY type of
+  arbitrary nesting. Properties defined on args.state will be retained
+  across frames. If you attempt access a property that doesn't exist
+  on args.state, it will simply return nil (no exception will be thrown).
+
+=end
+
+# Along with outputs, inputs are also an essential part of video game development
+# DragonRuby can take input from keyboards, mouse, and controllers.
+# This sample app will cover keyboard input.
+
+# args.inputs.keyboard.key_up.a will check to see if the a key has been pressed
+# This will work with the other keys as well
+
+
+def tick args
+  tick_instructions args, "Sample app shows how keyboard events are registered and accessed.", 360
+  # Notice how small_font accounts for all the remaining parameters
+  args.outputs.labels << [460, row_to_px(args, 0), "Current game time: #{args.state.tick_count}", small_font]
+  args.outputs.labels << [460, row_to_px(args, 2), "Keyboard input: args.inputs.keyboard.key_up.h", small_font]
+  args.outputs.labels << [460, row_to_px(args, 3), "Press \"h\" on the keyboard.", small_font]
+
+  # Input on a specifc key can be found through args.inputs.keyboard.key_up followed by the key
+  if args.inputs.keyboard.key_up.h
+    args.state.h_pressed_at = args.state.tick_count
+  end
+
+  # This code simplifies to if args.state.h_pressed_at has not been initialized, set it to false
+  args.state.h_pressed_at ||= false
+
+  if args.state.h_pressed_at
+    args.outputs.labels << [460, row_to_px(args, 4), "\"h\" was pressed at time: #{args.state.h_pressed_at}", small_font]
+  else
+    args.outputs.labels << [460, row_to_px(args, 4), "\"h\" has never been pressed.", small_font]
+  end
+
+  tick_help_text args
+end
+
+def small_font
+  # This method provides some values for the construction of labels
+  # Specifically, Size, Alignment, & RGBA
+  # This makes it so that custom parameters don't have to be repeatedly typed.
+  # Additionally "small_font" provides programmers with more information than some numbers
+  [-2, 0, 0, 0, 0, 255]
+end
+
+def row_to_px args, row_number
+  # This takes a row_number and converts it to pixels DragonRuby understands.
+  # Row 0 starts 5 units below the top of the grid
+  # Each row afterward is 20 units lower
+  args.grid.top.shift_down(5).shift_down(20 * row_number)
+end
+
+# Don't worry about understanding the code within this method just yet.
+# This method shows you the help text within the game.
+def tick_help_text args
+  return unless args.state.h_pressed_at
+
+  args.state.key_value_history      ||= {}
+  args.state.key_down_value_history ||= {}
+  args.state.key_held_value_history ||= {}
+  args.state.key_up_value_history   ||= {}
+
+  if (args.inputs.keyboard.key_down.truthy_keys.length > 0 ||
+      args.inputs.keyboard.key_held.truthy_keys.length > 0 ||
+      args.inputs.keyboard.key_up.truthy_keys.length > 0)
+    args.state.help_available = true
+    args.state.no_activity_debounce = nil
+  else
+    args.state.no_activity_debounce ||= 5.seconds
+    args.state.no_activity_debounce -= 1
+    if args.state.no_activity_debounce <= 0
+      args.state.help_available = false
+      args.state.key_value_history        = {}
+      args.state.key_down_value_history   = {}
+      args.state.key_held_value_history   = {}
+      args.state.key_up_value_history     = {}
+    end
+  end
+
+  args.outputs.labels << [10, row_to_px(args, 6), "Advanced Help:", small_font]
+
+  if !args.state.help_available
+    args.outputs.labels << [10, row_to_px(args, 7),  "Press a key and I'll show code to access the key and what value will be returned if you used the code.", small_font]
+    return
+  end
+
+  args.outputs.labels << [10 , row_to_px(args, 7), "args.inputs.keyboard", small_font]
+  args.outputs.labels << [330, row_to_px(args, 7), "args.inputs.keyboard.key_down", small_font]
+  args.outputs.labels << [650, row_to_px(args, 7), "args.inputs.keyboard.key_held", small_font]
+  args.outputs.labels << [990, row_to_px(args, 7), "args.inputs.keyboard.key_up", small_font]
+
+  fill_history args, :key_value_history,      :down_or_held, nil
+  fill_history args, :key_down_value_history, :down,        :key_down
+  fill_history args, :key_held_value_history, :held,        :key_held
+  fill_history args, :key_up_value_history,   :up,          :key_up
+
+  render_help_labels args, :key_value_history,      :down_or_held, nil,      10
+  render_help_labels args, :key_down_value_history, :down,        :key_down, 330
+  render_help_labels args, :key_held_value_history, :held,        :key_held, 650
+  render_help_labels args, :key_up_value_history,   :up,          :key_up,   990
+end
+
+def fill_history args, history_key, state_key, keyboard_method
+  fill_single_history args, history_key, state_key, keyboard_method, :raw_key
+  fill_single_history args, history_key, state_key, keyboard_method, :char
+  args.inputs.keyboard.keys[state_key].each do |key_name|
+    fill_single_history args, history_key, state_key, keyboard_method, key_name
+  end
+end
+
+def fill_single_history args, history_key, state_key, keyboard_method, key_name
+  current_value = args.inputs.keyboard.send(key_name)
+  if keyboard_method
+    current_value = args.inputs.keyboard.send(keyboard_method).send(key_name)
+  end
+  args.state.as_hash[history_key][key_name] ||= []
+  args.state.as_hash[history_key][key_name] << current_value
+  args.state.as_hash[history_key][key_name] = args.state.as_hash[history_key][key_name].reverse.uniq.take(3).reverse
+end
+
+def render_help_labels args, history_key, state_key, keyboard_method, x
+  idx = 8
+  args.outputs.labels << args.state
+                           .as_hash[history_key]
+                           .keys
+                           .reverse
+                           .map
+                           .with_index do |k, i|
+    v = args.state.as_hash[history_key][k]
+    current_value = args.inputs.keyboard.send(k)
+    if keyboard_method
+      current_value = args.inputs.keyboard.send(keyboard_method).send(k)
+    end
+    idx += 2
+    [
+      [x, row_to_px(args, idx - 2),
+       "    .#{k} is #{current_value || "nil"}",
+       small_font],
+      [x, row_to_px(args, idx - 1),
+       "       was #{v}",
+       small_font]
+    ]
+  end
+end
+
+
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
+  end
+
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+end
+
+
+Input Basics - Mouse - main.rb
+# ./samples/02_input_basics/02_mouse/app/main.rb
+=begin
+
+APIs that haven't been encountered in a previous sample apps:
+
+- args.inputs.mouse.click: This property will be set if the mouse was clicked.
+- args.inputs.mouse.click.point.(x|y): The x and y location of the mouse.
+- args.inputs.mouse.click.point.created_at: The frame the mouse click occurred in.
+- args.inputs.mouse.click.point.created_at_elapsed: How many frames have passed
+  since the click event.
+
+Reminder:
+
+- args.state.PROPERTY: The state property on args is a dynamic
+  structure. You can define ANY property here with ANY type of
+  arbitrary nesting. Properties defined on args.state will be retained
+  across frames. If you attempt access a property that doesn't exist
+  on args.state, it will simply return nil (no exception will be thrown).
+
+=end
+
+# This code demonstrates DragonRuby mouse input
+
+# To see if the a mouse click occurred
+# Use args.inputs.mouse.click
+# Which returns a boolean
+
+# To see where a mouse click occurred
+# Use args.inputs.mouse.click.point.x AND
+# args.inputs.mouse.click.point.y
+
+# To see which frame the click occurred
+# Use args.inputs.mouse.click.created_at
+
+# To see how many frames its been since the click occurred
+# Use args.inputs.mouse.click.creat_at_elapsed
+
+# Saving the click in args.state can be quite useful
+
+def tick args
+  tick_instructions args, "Sample app shows how mouse events are registered and how to measure elapsed time."
+  x = 460
+
+  args.outputs.labels << small_label(args, x, 11, "Mouse input: args.inputs.mouse")
+
+  if args.inputs.mouse.click
+    args.state.last_mouse_click = args.inputs.mouse.click
+  end
+
+  if args.state.last_mouse_click
+    click = args.state.last_mouse_click
+    args.outputs.labels << small_label(args, x, 12, "Mouse click happened at: #{click.created_at}")
+    args.outputs.labels << small_label(args, x, 13, "Mouse clicked #{click.created_at_elapsed} ticks ago")
+    args.outputs.labels << small_label(args, x, 14, "Mouse click location: #{click.point.x}, #{click.point.y}")
+  else
+    args.outputs.labels << small_label(args, x, 12, "Mouse click has not occurred yet.")
+    args.outputs.labels << small_label(args, x, 13, "Please click mouse.")
+  end
+end
+
+def small_label args, x, row, message
+  # This method effectively combines the row_to_px and small_font methods
+  # It changes the given row value to a DragonRuby pixel value
+  # and adds the customization parameters
+  [x, row_to_px(args, row), message, small_font]
+end
+
+def small_font
+  [-2, 0, 0, 0, 0, 255]
+end
+
+def row_to_px args, row_number
+  args.grid.top.shift_down(5).shift_down(20 * row_number)
+end
+
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
+  end
+
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+end
+
+
+Input Basics - Mouse Point To Rect - main.rb
+# ./samples/02_input_basics/03_mouse_point_to_rect/app/main.rb
+=begin
+
+APIs that haven't been encountered in a previous sample apps:
+
+- args.outputus.borders: An array. Values in this array will be rendered as
+  unfilled rectangles on the screen.
+- ARRAY#inside_rect?: An array with at least two values is considered a point. An array
+  with at least four values is considered a rect. The inside_rect? function returns true
+  or false depending on if the point is inside the rect.
+
+  ```
+  # Point:  x: 100, y: 100
+  # Rect:   x: 0, y: 0, w: 500, h: 500
+  # Result: true
+
+  [100, 100].inside_rect? [0, 0, 500, 500]
+  ```
+
+  ```
+  # Point:  x: 100, y: 100
+  # Rect:   x: 300, y: 300, w: 100, h: 100
+  # Result: false
+
+  [100, 100].inside_rect? [300, 300, 100, 100]
+  ```
+
+- args.inputs.mouse.click.point.created_at: The frame the mouse click occurred in.
+- args.inputs.mouse.click.point.created_at_elapsed: How many frames have passed
+  since the click event.
+
+=end
+
+# To determine whether a point is in a rect
+# Use point.inside_rect? rect
+
+# This is useful to determine if a click occurred in a rect
+
+def tick args
+  tick_instructions args, "Sample app shows how to determing if a click happened inside a rectangle."
+
+  x = 460
+
+  args.outputs.labels << small_label(args, x, 15, "Click inside the blue box maybe ---->")
+
+  box = [785, 370, 50, 50, 0, 0, 170]
+  args.outputs.borders << box
+
+  # Saves the most recent click into args.state
+  # Unlike the other components of args,
+  # args.state does not reset every tick.
+  if args.inputs.mouse.click
+    args.state.last_mouse_click = args.inputs.mouse.click
+  end
+
+  if args.state.last_mouse_click
+    if args.state.last_mouse_click.point.inside_rect? box
+      args.outputs.labels << small_label(args, x, 16, "Mouse click happened *inside* the box.")
+    else
+      args.outputs.labels << small_label(args, x, 16, "Mouse click happened *outside* the box.")
+    end
+  else
+    args.outputs.labels << small_label(args, x, 16, "Mouse click has not occurred yet.")
+  end
+end
+
+def small_label args, x, row, message
+  [x, row_to_px(args, row), message, small_font]
+end
+
+def small_font
+  [-2, 0, 0, 0, 0, 255]
+end
+
+def row_to_px args, row_number
+  args.grid.top.shift_down(5).shift_down(20 * row_number)
+end
+
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
+  end
+
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+end
+
+
+Input Basics - Mouse Rect To Rect - main.rb
+# ./samples/02_input_basics/04_mouse_rect_to_rect/app/main.rb
+=begin
+
+APIs that haven't been encountered in a previous sample apps:
+
+- args.outputs.borders: An array. Values in this array will be rendered as
+  unfilled rectangles on the screen.
+- ARRAY#intersect_rect?: An array with at least four values is
+  considered a rect. The intersect_rect? function returns true
+  or false depending on if the two rectangles intersect.
+
+  ```
+  # Rect One: x: 100, y: 100, w: 100, h: 100
+  # Rect Two: x: 0, y: 0, w: 500, h: 500
+  # Result:   true
+
+  [100, 100, 100, 100].intersect_rect? [0, 0, 500, 500]
+  ```
+
+  ```
+  # Rect One: x: 100, y: 100, w: 10, h: 10
+  # Rect Two: x: 500, y: 500, w: 10, h: 10
+  # Result:   false
+
+  [100, 100, 10, 10].intersect_rect? [500, 500, 10, 10]
+  ```
+
+=end
+
+# Similarly, whether rects intersect can be found through
+# rect1.intersect_rect? rect2
+
+def tick args
+  tick_instructions args, "Sample app shows how to determine if two rectangles intersect."
+  x = 460
+
+  args.outputs.labels << small_label(args, x, 3, "Click anywhere on the screen")
+  # red_box = [460, 250, 355, 90, 170, 0, 0]
+  # args.outputs.borders << red_box
+
+  # args.state.box_collision_one and args.state.box_collision_two
+  # Are given values of a solid when they should be rendered
+  # They are stored in game so that they do not get reset every tick
+  if args.inputs.mouse.click
+    if !args.state.box_collision_one
+      args.state.box_collision_one = [args.inputs.mouse.click.point.x - 25, args.inputs.mouse.click.point.y - 25, 125, 125, 180, 0,   0, 180]
+    elsif !args.state.box_collision_two
+      args.state.box_collision_two = [args.inputs.mouse.click.point.x - 25, args.inputs.mouse.click.point.y - 25, 125, 125,   0, 0, 180, 180]
+    else
+      args.state.box_collision_one = nil
+      args.state.box_collision_two = nil
+    end
+  end
+
+  if args.state.box_collision_one
+    args.outputs.solids << args.state.box_collision_one
+  end
+
+  if args.state.box_collision_two
+    args.outputs.solids << args.state.box_collision_two
+  end
+
+  if args.state.box_collision_one && args.state.box_collision_two
+    if args.state.box_collision_one.intersect_rect? args.state.box_collision_two
+      args.outputs.labels << small_label(args, x, 4, 'The boxes intersect.')
+    else
+      args.outputs.labels << small_label(args, x, 4, 'The boxes do not intersect.')
+    end
+  else
+    args.outputs.labels << small_label(args, x, 4, '--')
+  end
+end
+
+def small_label args, x, row, message
+  [x, row_to_px(args, row), message, small_font]
+end
+
+def small_font
+  [-2, 0, 0, 0, 0, 255]
+end
+
+def row_to_px args, row_number
+  args.grid.top.shift_down(5).shift_down(20 * row_number)
+end
+
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
+  end
+
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+end
+
+
+Input Basics - Controller - main.rb
+# ./samples/02_input_basics/05_controller/app/main.rb
+=begin
+
+ APIs listing that haven't been encountered in previous sample apps:
+
+ - args.inputs.controller_one.key_held.KEY: Will check to see if a specific key
+   is being held down on the controller.
+   If there is more than one controller being used, they can be differentiated by
+   using names like controller_one and controller_two.
+
+   For a full listing of buttons, take a look at mygame/documentation/08-controllers.md.
+
+ Reminder:
+
+ - args.state.PROPERTY: The state property on args is a dynamic
+   structure. You can define ANY property here with ANY type of
+   arbitrary nesting. Properties defined on args.state will be retained
+   across frames. If you attempt to access a property that doesn't exist
+   on args.state, it will simply return nil (no exception will be thrown).
+
+   In this sample app, args.state.BUTTONS is an array that stores the buttons of the controller.
+   The parameters of a button are:
+   1. the position (x, y)
+   2. the input key held on the controller
+   3. the text or name of the button
+
+=end
+
+# This sample app provides a visual demonstration of a standard controller, including
+# the placement and function of all buttons.
+
+class ControllerDemo
+  attr_accessor :inputs, :state, :outputs
+
+  # Calls the methods necessary for the app to run successfully.
+  def tick
+    process_inputs
+    render
+  end
+
+  # Starts with an empty collection of buttons.
+  # Adds buttons that are on the controller to the collection.
+  def process_inputs
+    state.buttons = []
+
+    state.buttons << [100, 500, inputs.controller_one.key_held.l1, "L1"]
+    state.buttons << [100, 600, inputs.controller_one.key_held.l2, "L2"]
+
+    state.buttons << [1100, 500, inputs.controller_one.key_held.r1, "R1"]
+    state.buttons << [1100, 600, inputs.controller_one.key_held.r2, "R2"]
+
+    state.buttons << [540, 450, inputs.controller_one.key_held.select, "Select"]
+    state.buttons << [660, 450, inputs.controller_one.key_held.start, "Start"]
+
+    state.buttons << [200, 300, inputs.controller_one.key_held.left, "Left"]
+    state.buttons << [300, 400, inputs.controller_one.key_held.up, "Up"]
+    state.buttons << [400, 300, inputs.controller_one.key_held.right, "Right"]
+    state.buttons << [300, 200, inputs.controller_one.key_held.down, "Down"]
+
+    state.buttons << [800, 300, inputs.controller_one.key_held.x, "X"]
+    state.buttons << [900, 400, inputs.controller_one.key_held.y, "Y"]
+    state.buttons << [1000, 300, inputs.controller_one.key_held.a, "A"]
+    state.buttons << [900, 200, inputs.controller_one.key_held.b, "B"]
+
+    state.buttons << [450 + inputs.controller_one.left_analog_x_perc * 100,
+                      100 + inputs.controller_one.left_analog_y_perc * 100,
+                      inputs.controller_one.key_held.l3,
+                      "L3"]
+
+    state.buttons << [750 + inputs.controller_one.right_analog_x_perc * 100,
+                      100 + inputs.controller_one.right_analog_y_perc * 100,
+                      inputs.controller_one.key_held.r3,
+                      "R3"]
+  end
+
+  # Gives each button a square shape.
+  # If the button is being pressed or held (which means it is considered active),
+  # the square is filled in. Otherwise, the button simply has a border.
+  def render
+    state.buttons.each do |x, y, active, text|
+      rect = [x, y, 75, 75]
+
+      if active # if button is pressed
+        outputs.solids << rect # rect is output as solid (filled in)
+      else
+        outputs.borders << rect # otherwise, output as border
+      end
+
+      # Outputs the text of each button using labels.
+      outputs.labels << [x, y + 95, text] # add 95 to place label above button
+    end
+
+    outputs.labels << [10, 60, "Left Analog x: #{inputs.controller_one.left_analog_x_raw} (#{inputs.controller_one.left_analog_x_perc * 100}%)"]
+    outputs.labels << [10, 30, "Left Analog y: #{inputs.controller_one.left_analog_y_raw} (#{inputs.controller_one.left_analog_y_perc * 100}%)"]
+    outputs.labels << [900, 60, "Right Analog x: #{inputs.controller_one.right_analog_x_raw} (#{inputs.controller_one.right_analog_x_perc * 100}%)"]
+    outputs.labels << [900, 30, "Right Analog y: #{inputs.controller_one.right_analog_y_raw} (#{inputs.controller_one.right_analog_y_perc * 100}%)"]
+  end
+end
+
+$controller_demo = ControllerDemo.new
+
+def tick args
+  tick_instructions args, "Sample app shows how controller input is handled. You'll need to connect a USB controller."
+  $controller_demo.inputs = args.inputs
+  $controller_demo.state = args.state
+  $controller_demo.outputs = args.outputs
+  $controller_demo.tick
+end
+
+# Resets the app.
+def r
+  $gtk.reset
+end
+
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
+  end
+
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+end
+
+
+Input Basics - Touch - main.rb
+# ./samples/02_input_basics/06_touch/app/main.rb
+def tick args
+  args.outputs.background_color = [ 0, 0, 0 ]
+  args.outputs.primitives << [640, 700, "Touch your screen.", 5, 1, 255, 255, 255].label
+
+  # If you don't want to get fancy, you can just look for finger_one
+  #  (and _two, if you like), which are assigned in the order new touches hit
+  #  the screen. If not nil, they are touching right now, and are just
+  #  references to specific items in the args.input.touch hash.
+  # If finger_one lifts off, it will become nil, but finger_two, if it was
+  #  touching, remains until it also lifts off. When all fingers lift off, the
+  #  the next new touch will be finger_one again, but until then, new touches
+  #  don't fill in earlier slots.
+  if !args.inputs.finger_one.nil?
+    args.outputs.primitives << [640, 650, "Finger #1 is touching at (#{args.inputs.finger_one.x}, #{args.inputs.finger_one.y}).", 5, 1, 255, 255, 255].label
+  end
+  if !args.inputs.finger_two.nil?
+    args.outputs.primitives << [640, 600, "Finger #2 is touching at (#{args.inputs.finger_two.x}, #{args.inputs.finger_two.y}).", 5, 1, 255, 255, 255].label
+  end
+
+  # Here's the more flexible interface: this will report as many simultaneous
+  #  touches as the system can handle, but it's a little more effort to track
+  #  them. Each item in the args.input.touch hash has a unique key (an
+  #  incrementing integer) that exists until the finger lifts off. You can
+  #  tell which order the touches happened globally by the key value, or
+  #  by the touch[id].touch_order field, which resets to zero each time all
+  #  touches have lifted.
+
+  args.state.colors ||= [
+    0xFF0000, 0x00FF00, 0x1010FF, 0xFFFF00, 0xFF00FF, 0x00FFFF, 0xFFFFFF
+  ]
+
+  size = 100
+  args.inputs.touch.each { |k,v|
+    color = args.state.colors[v.touch_order % 7]
+    r = (color & 0xFF0000) >> 16
+    g = (color & 0x00FF00) >> 8
+    b = (color & 0x0000FF)
+    args.outputs.primitives << [v.x - (size / 2), v.y + (size / 2), size, size, r, g, b, 255].solid
+    args.outputs.primitives << [v.x, v.y + size, k.to_s, 0, 1, 0, 0, 0].label
+  }
+end
+
+
+
+Rendering Sprites - Animation Using Separate Pngs - main.rb
+# ./samples/03_rendering_sprites/01_animation_using_separate_pngs/app/main.rb
+=begin
+
+ Reminders:
+
+ - String interpolation: Uses #{} syntax; everything between the #{ and the } is evaluated
+   as Ruby code, and the placeholder is replaced with its corresponding value or result.
+
+   In this sample app, we're using string interpolation to iterate through images in the
+   sprites folder using their image path names.
+
+ - args.outputs.sprites: An array. Values in this array generate sprites on the screen.
+   The parameters are [X, Y, WIDTH, HEIGHT, IMAGE PATH]
+   For more information about sprites, go to mygame/documentation/05-sprites.md.
+
+ - args.outputs.labels: An array. Values in the array generate labels on the screen.
+   The parameters are [X, Y, TEXT, SIZE, ALIGNMENT, RED, GREEN, BLUE, ALPHA, FONT STYLE]
+   For more information about labels, go to mygame/documentation/02-labels.md.
+
+ - args.inputs.keyboard.key_down.KEY: Determines if a key is in the down state, or pressed.
+   Stores the frame that key was pressed on.
+   For more information about the keyboard, go to mygame/documentation/06-keyboard.md.
+
+=end
+
+# This sample app demonstrates how sprite animations work.
+# There are two sprites that animate forever and one sprite
+# that *only* animates when you press the "f" key on the keyboard.
+
+# This is the entry point to your game. The `tick` method
+# executes at 60 frames per second. There are two methods
+# in this tick "entry point": `looping_animation`, and the
+# second method is `one_time_animation`.
+def tick args
+  looping_animation args
+  one_time_animation args
+end
+
+# This function shows how to animate a sprite that loops forever.
+def looping_animation args
+  # Here we define a few local variables that will be sent
+  # into the magic function that gives us the correct sprite image
+  # over time. There are four things we need in order to figure
+  # out which sprite to show.
+
+  # 1. When to start the animation.
+  start_looping_at = 0
+
+  # 2. The number of pngs that represent the full animation.
+  number_of_sprites = 6
+
+  # 3. How long to show each png.
+  number_of_frames_to_show_each_sprite = 4
+
+  # 4. Whether the animation should loop once, or forever.
+  does_sprite_loop = true
+
+  # With the variables defined above, we can get a number
+  # which represents the sprite to show by calling the `frame_index` function.
+  # In this case the number will be between 0, and 5 (you can see the sprites
+  # in the ./sprites directory).
+  sprite_index = start_looping_at.frame_index number_of_sprites,
+                                              number_of_frames_to_show_each_sprite,
+                                              does_sprite_loop
+
+  # Now that we have `sprite_index, we can present the correct file.
+  args.outputs.sprites << [100, 100, 100, 100, "sprites/dragon_fly_#{sprite_index}.png"]
+
+  # Try changing the numbers below to see how the animation changes:
+  args.outputs.sprites << [100, 200, 100, 100, "sprites/dragon_fly_#{0.frame_index 6, 4, true}.png"]
+end
+
+# This function shows how to animate a sprite that executes
+# only once when the "f" key is pressed.
+def one_time_animation args
+  # This is just a label the shows instructions within the game.
+  args.outputs.labels << [220, 350, "(press f to animate)"]
+
+  # If "f" is pressed on the keyboard...
+  if args.inputs.keyboard.key_down.f
+    # Print the frame that "f" was pressed on.
+    puts "Hello from main.rb! The \"f\" key was in the down state on frame: #{args.inputs.keyboard.key_down.f}"
+
+    # And MOST IMPORTANTLY set the point it time to start the animation,
+    # equal to "now" which is represented as args.state.tick_count.
+
+    # Also IMPORTANT, you'll notice that the value of when to start looping
+    # is stored in `args.state`. This construct's values are retained across
+    # executions of the `tick` method.
+    args.state.start_looping_at = args.state.tick_count
+  end
+
+  # These are the same local variables that were defined
+  # for the `looping_animation` function.
+  number_of_sprites = 6
+  number_of_frames_to_show_each_sprite = 4
+
+  # Except this sprite does not loop again. If the animation time has passed,
+  # then the frame_index function returns nil.
+  does_sprite_loop = false
+
+  sprite_index = args.state
+                     .start_looping_at
+                     .frame_index number_of_sprites,
+                                  number_of_frames_to_show_each_sprite,
+                                  does_sprite_loop
+
+  # This line sets the frame index to zero, if
+  # the animation duration has passed (frame_index returned nil).
+
+  # Remeber: we are not looping forever here.
+  sprite_index ||= 0
+
+  # Present the sprite.
+  args.outputs.sprites << [100, 300, 100, 100, "sprites/dragon_fly_#{sprite_index}.png"]
+
+  tick_instructions args, "Sample app shows how to use Numeric#frame_index and string interpolation to animate a sprite over time."
+end
+
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
+  end
+
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+end
+
+
+Rendering Sprites - Animation Using Sprite Sheet - main.rb
+# ./samples/03_rendering_sprites/02_animation_using_sprite_sheet/app/main.rb
+def tick args
+  args.state.player.x ||= 100
+  args.state.player.y ||= 100
+  args.state.player.w ||= 64
+  args.state.player.h ||= 64
+  args.state.player.direction ||= 1
+
+  args.state.player.is_moving = false
+
+  # get the keyboard input and set player properties
+  if args.inputs.keyboard.right
+    args.state.player.x += 3
+    args.state.player.direction = 1
+    args.state.player.started_running_at ||= args.state.tick_count
+  elsif args.inputs.keyboard.left
+    args.state.player.x -= 3
+    args.state.player.direction = -1
+    args.state.player.started_running_at ||= args.state.tick_count
+  end
+
+  if args.inputs.keyboard.up
+    args.state.player.y += 1
+    args.state.player.started_running_at ||= args.state.tick_count
+  elsif args.inputs.keyboard.down
+    args.state.player.y -= 1
+    args.state.player.started_running_at ||= args.state.tick_count
+  end
+
+  # if no arrow keys are being pressed, set the player as not moving
+  if !args.inputs.keyboard.directional_vector
+    args.state.player.started_running_at = nil
+  end
+
+  # wrap player around the stage
+  if args.state.player.x > 1280
+    args.state.player.x = -64
+    args.state.player.started_running_at ||= args.state.tick_count
+  elsif args.state.player.x < -64
+    args.state.player.x = 1280
+    args.state.player.started_running_at ||= args.state.tick_count
+  end
+
+  if args.state.player.y > 720
+    args.state.player.y = -64
+    args.state.player.started_running_at ||= args.state.tick_count
+  elsif args.state.player.y < -64
+    args.state.player.y = 720
+    args.state.player.started_running_at ||= args.state.tick_count
+  end
+
+  # render player as standing or running
+  if args.state.player.started_running_at
+    args.outputs.sprites << running_sprite(args)
+  else
+    args.outputs.sprites << standing_sprite(args)
+  end
+  args.outputs.labels << [30, 700, "Use arrow keys to move around."]
+end
+
+def standing_sprite args
+  {
+    x: args.state.player.x,
+    y: args.state.player.y,
+    w: args.state.player.w,
+    h: args.state.player.h,
+    path: "sprites/horizontal-stand.png",
+    flip_horizontally: args.state.player.direction > 0
+  }
+end
+
+def running_sprite args
+  if !args.state.player.started_running_at
+    tile_index = 0
+  else
+    how_many_frames_in_sprite_sheet = 6
+    how_many_ticks_to_hold_each_frame = 3
+    should_the_index_repeat = true
+    tile_index = args.state
+                     .player
+                     .started_running_at
+                     .frame_index(how_many_frames_in_sprite_sheet,
+                                  how_many_ticks_to_hold_each_frame,
+                                  should_the_index_repeat)
+  end
+
+  {
+    x: args.state.player.x,
+    y: args.state.player.y,
+    w: args.state.player.w,
+    h: args.state.player.h,
+    path: 'sprites/horizontal-run.png',
+    tile_x: 0 + (tile_index * args.state.player.w),
+    tile_y: 0,
+    tile_w: args.state.player.w,
+    tile_h: args.state.player.h,
+    flip_horizontally: args.state.player.direction > 0,
+  }
+end
+
+
+Rendering Sprites - Animation States - main.rb
+# ./samples/03_rendering_sprites/03_animation_states/app/main.rb
+class Game
+  attr_gtk
+
+  def defaults
+    state.show_debug_layer  = true if state.tick_count == 0
+    player.tile_size        = 64
+    player.speed            = 3
+    player.slash_frames     = 15
+    player.x              ||= 50
+    player.y              ||= 400
+    player.dir_x          ||=  1
+    player.dir_y          ||= -1
+    player.is_moving      ||= false
+    state.watch_list      ||= {}
+    state.enemies         ||= []
+  end
+
+  def add_enemy
+    state.enemies << { x: 1200 * rand, y: 600 * rand, w: 64, h: 64 }
+  end
+
+  def sprite_horizontal_run
+    tile_index = 0.frame_index(6, 3, true)
+    tile_index = 0 if !player.is_moving
+
+    {
+      x: player.x,
+      y: player.y,
+      w: player.tile_size,
+      h: player.tile_size,
+      path: 'sprites/horizontal-run.png',
+      tile_x: 0 + (tile_index * player.tile_size),
+      tile_y: 0,
+      tile_w: player.tile_size,
+      tile_h: player.tile_size,
+      flip_horizontally: player.dir_x > 0,
+      # a: 40
+    }
+  end
+
+  def sprite_horizontal_stand
+    {
+      x: player.x,
+      y: player.y,
+      w: player.tile_size,
+      h: player.tile_size,
+      path: 'sprites/horizontal-stand.png',
+      flip_horizontally: player.dir_x > 0,
+      # a: 40
+    }
+  end
+
+  def sprite_horizontal_slash
+    tile_index   = player.slash_at.frame_index(5, player.slash_frames.idiv(5), false) || 0
+
+    {
+      x: player.x - 41.25,
+      y: player.y - 41.25,
+      w: 165,
+      h: 165,
+      path: 'sprites/horizontal-slash.png',
+      tile_x: 0 + (tile_index * 128),
+      tile_y: 0,
+      tile_w: 128,
+      tile_h: 128,
+      flip_horizontally: player.dir_x > 0
+    }
+  end
+
+  def render_player
+    if player.slash_at
+      outputs.sprites << sprite_horizontal_slash
+    elsif player.is_moving
+      outputs.sprites << sprite_horizontal_run
+    else
+      outputs.sprites << sprite_horizontal_stand
+    end
+  end
+
+  def render_enemies
+    outputs.borders << state.enemies
+  end
+
+  def render_debug_layer
+    return if !state.show_debug_layer
+    outputs.labels << state.watch_list.map.with_index do |(k, v), i|
+       [30, 710 - i * 28, "#{k}: #{v || "(nil)"}"]
+    end
+
+    outputs.borders << player.slash_collision_rect
+  end
+
+  def slash_initiate?
+    # buffalo usb controller has a button and b button swapped lol
+    inputs.controller_one.key_down.a || inputs.keyboard.key_down.j
+  end
+
+  def input
+    # player movement
+    if slash_complete? && (vector = inputs.directional_vector)
+      player.x += vector.x * player.speed
+      player.y += vector.y * player.speed
+    end
+    player.slash_at = slash_initiate? if slash_initiate?
+  end
+
+  def calc_movement
+    # movement
+    if vector = inputs.directional_vector
+      state.debug_label = vector
+      player.dir_x = vector.x
+      player.dir_y = vector.y
+      player.is_moving = true
+    else
+      state.debug_label = vector
+      player.is_moving = false
+    end
+  end
+
+  def calc_slash
+    # re-calc the location of the swords collision box
+    if player.dir_x.positive?
+      player.slash_collision_rect = [player.x + player.tile_size,
+                                     player.y + player.tile_size.half - 10,
+                                     40, 20]
+    else
+      player.slash_collision_rect = [player.x - 32 - 8,
+                                     player.y + player.tile_size.half - 10,
+                                     40, 20]
+    end
+
+    # recalc sword's slash state
+    player.slash_at = nil if slash_complete?
+
+    # determine collision if the sword is at it's point of damaging
+    return unless slash_can_damage?
+
+    state.enemies.reject! { |e| e.intersect_rect? player.slash_collision_rect }
+  end
+
+  def slash_complete?
+    !player.slash_at || player.slash_at.elapsed?(player.slash_frames)
+  end
+
+  def slash_can_damage?
+    # damage occurs half way into the slash animation
+    return false if slash_complete?
+    return false if (player.slash_at + player.slash_frames.idiv(2)) != state.tick_count
+    return true
+  end
+
+  def calc
+    # generate an enemy if there aren't any on the screen
+    add_enemy if state.enemies.length == 0
+    calc_movement
+    calc_slash
+  end
+
+  # source is at http://github.com/amirrajan/dragonruby-link-to-the-past
+  def tick
+    defaults
+    render_enemies
+    render_player
+    outputs.labels << [30, 30, "Gamepad: D-Pad to move. B button to attack."]
+    outputs.labels << [30, 52, "Keyboard: WASD/Arrow keys to move. J to attack."]
+    render_debug_layer
+    input
+    calc
+  end
+
+  def player
+    state.player
+  end
+end
+
+$game = Game.new
+
+def tick args
+  $game.args = args
+  $game.tick
+end
+
+$gtk.reset
+
+
+Rendering Sprites - Color And Rotation - main.rb
+# ./samples/03_rendering_sprites/04_color_and_rotation/app/main.rb
+=begin
+ APIs listing that haven't been encountered in previous sample apps:
+
+ - merge: Returns a hash containing the contents of two original hashes.
+   Merge does not allow duplicate keys, so the value of a repeated key
+   will be overwritten.
+
+   For example, if we had two hashes
+   h1 = { "a" => 1, "b" => 2}
+   h2 = { "b" => 3, "c" => 3}
+   and we called the command
+   h1.merge(h2)
+   the result would the following hash
+   { "a" => 1, "b" => 3, "c" => 3}.
+
+ Reminders:
+
+ - Hashes: Collection of unique keys and their corresponding values. The value can be found
+   using their keys.
+   In this sample app, we're using a hash to create a sprite.
+
+ - args.outputs.sprites: An array. The values generate a sprite.
+   The parameters are [X, Y, WIDTH, HEIGHT, PATH, ANGLE, ALPHA, RED, GREEN, BLUE]
+   Before continuing with this sample app, it is HIGHLY recommended that you look
+   at mygame/documentation/05-sprites.md.
+
+ - args.inputs.keyboard.key_held.KEY: Determines if a key is being pressed.
+   For more information about the keyboard, go to mygame/documentation/06-keyboard.md.
+
+ - args.inputs.controller_one: Takes input from the controller based on what key is pressed.
+   For more information about the controller, go to mygame/documentation/08-controllers.md.
+
+ - num1.lesser(num2): Finds the lower value of the given options.
+
+=end
+
+# This sample app shows a car moving across the screen. It loops back around if it exceeds the dimensions of the screen,
+# and also can be moved in different directions through keyboard input from the user.
+
+# Calls the methods necessary for the game to run successfully.
+def tick args
+  default args
+  render args.grid, args.outputs, args.state
+  calc args.state
+  process_inputs args
+end
+
+# Sets default values for the car sprite
+# Initialization ||= only happens in the first frame
+def default args
+  args.state.sprite.width    = 19
+  args.state.sprite.height   = 10
+  args.state.sprite.scale    = 4
+  args.state.max_speed       = 5
+  args.state.x             ||= 100
+  args.state.y             ||= 100
+  args.state.speed         ||= 1
+  args.state.angle         ||= 0
+end
+
+# Outputs sprite onto screen
+def render grid, outputs, state
+  outputs.solids  <<  [grid.rect, 70, 70, 70] # outputs gray background
+  outputs.sprites <<  [destination_rect(state), # sets first four parameters of car sprite
+  'sprites/86.png', # image path of car
+  state.angle,
+  opacity, # transparency
+  saturation,
+  source_rect(state), # sprite sub division/tile (tile x, y, w, h)
+  false, false,  # don't flip sprites
+  rotation_anchor]
+
+  # also look at the create_sprite helper method
+  #
+  # For example:
+  #
+  # dest   = destination_rect(state)
+  # source = source_rect(state),
+  # outputs.sprites << create_sprite(
+  #   'sprites/86.png',
+  #   x: dest.x,
+  #   y: dest.y,
+  #   w: dest.w,
+  #   h: dest.h,
+  #   angle: state.angle,
+  #   source_x: source.x,
+  #   source_y: source.y,
+  #   source_w: source.w,
+  #   source_h: source.h,
+  #   flip_h: false,
+  #   flip_v: false,
+  #   rotation_anchor_x: 0.7,
+  #   rotation_anchor_y: 0.5
+  # )
+end
+
+# Creates sprite by setting values inside of a hash
+def create_sprite path, options = {}
+  options = {
+
+    # dest x, y, w, h
+    x: 0,
+    y: 0,
+    w: 100,
+    h: 100,
+
+    # angle, rotation
+    angle: 0,
+    rotation_anchor_x: 0.5,
+    rotation_anchor_y: 0.5,
+
+    # color saturation (red, green, blue), transparency
+    r: 255,
+    g: 255,
+    b: 255,
+    a: 255,
+
+    # source x, y, width, height
+    source_x: 0,
+    source_y: 0,
+    source_w: -1,
+    source_h: -1,
+
+    # flip horiztonally, flip vertically
+    flip_h: false,
+    flip_v: false,
+
+  }.merge options
+
+  [
+    options[:x], options[:y], options[:w], options[:h], # dest rect keys
+    path,
+    options[:angle], options[:a], options[:r], options[:g], options[:b], # angle, color, alpha
+    options[:source_x], options[:source_y], options[:source_w], options[:source_h], # source rect keys
+    options[:flip_h], options[:flip_v], # flip
+    options[:rotation_anchor_x], options[:rotation_anchor_y], # rotation anchor
+  ] # hash keys contain corresponding values
+end
+
+# Calls the calc_pos and calc_wrap methods.
+def calc state
+  calc_pos state
+  calc_wrap state
+end
+
+# Changes sprite's position on screen
+# Vectors have magnitude and direction, so the incremented x and y values give the car direction
+def calc_pos state
+  state.x     += state.angle.vector_x * state.speed # increments x by product of angle's x vector and speed
+  state.y     += state.angle.vector_y * state.speed # increments y by product of angle's y vector and speed
+  state.speed *= 1.1 # scales speed up
+  state.speed  = state.speed.lesser(state.max_speed) # speed is either current speed or max speed, whichever has a lesser value (ensures that the car doesn't go too fast or exceed the max speed)
+end
+
+# The screen's dimensions are 1280x720. If the car goes out of scope,
+# it loops back around on the screen.
+def calc_wrap state
+
+  # car returns to left side of screen if it disappears on right side of screen
+  # sprite.width refers to tile's size, which is multipled by scale (4) to make it bigger
+  state.x = -state.sprite.width * state.sprite.scale if state.x - 20 > 1280
+
+  # car wraps around to right side of screen if it disappears on the left side
+  state.x = 1280 if state.x + state.sprite.width * state.sprite.scale + 20 < 0
+
+  # car wraps around to bottom of screen if it disappears at the top of the screen
+  # if you subtract 520 pixels instead of 20 pixels, the car takes longer to reappear (try it!)
+  state.y = 0    if state.y - 20 > 720 # if 20 pixels less than car's y position is greater than vertical scope
+
+  # car wraps around to top of screen if it disappears at the bottom of the screen
+  state.y = 720  if state.y + state.sprite.height * state.sprite.scale + 20 < 0
+end
+
+# Changes angle of sprite based on user input from keyboard or controller
+def process_inputs args
+
+  # NOTE: increasing the angle doesn't mean that the car will continue to go
+  # in a specific direction. The angle is increasing, which means that if the
+  # left key was kept in the "down" state, the change in the angle would cause
+  # the car to go in a counter-clockwise direction and form a circle (360 degrees)
+  if args.inputs.keyboard.key_held.left # if left key is pressed
+    args.state.angle += 2 # car's angle is incremented by 2
+
+  # The same applies to decreasing the angle. If the right key was kept in the
+  # "down" state, the decreasing angle would cause the car to go in a clockwise
+  # direction and form a circle (360 degrees)
+  elsif args.inputs.keyboard.key_held.right # if right key is pressed
+    args.state.angle -= 2 # car's angle is decremented by 2
+
+  # Input from a controller can also change the angle of the car
+  elsif args.inputs.controller_one.left_analog_x_perc != 0
+    args.state.angle += 2 * args.inputs.controller_one.left_analog_x_perc * -1
+  end
+end
+
+# A sprite's center of rotation can be altered
+# Increasing either of these numbers would dramatically increase the
+# car's drift when it turns!
+def rotation_anchor
+  [0.7, 0.5]
+end
+
+# Sets opacity value of sprite to 255 so that it is not transparent at all
+# Change it to 0 and you won't be able to see the car sprite on the screen
+def opacity
+  255
+end
+
+# Sets the color of the sprite to white.
+def saturation
+  [255, 255, 255]
+end
+
+# Sets definition of destination_rect (used to define the car sprite)
+def destination_rect state
+  [state.x, state.y,
+  state.sprite.width  * state.sprite.scale, # multiplies by 4 to set size
+  state.sprite.height * state.sprite.scale]
+end
+
+# Portion of a sprite (a tile)
+# Sub division of sprite is denoted as a rectangle directly related to original size of .png
+# Tile is located at bottom left corner within a 19x10 pixel rectangle (based on sprite.width, sprite.height)
+def source_rect state
+  [0, 0, state.sprite.width, state.sprite.height]
+end
+
+
+Physics And Collisions - Simple - main.rb
+# ./samples/04_physics_and_collisions/01_simple/app/main.rb
+=begin
+
+ Reminders:
+ - ARRAY#intersect_rect?: Returns true or false depending on if the two rectangles intersect.
+
+ - args.outputs.solids: An array. The values generate a solid.
+   The parameters are [X, Y, WIDTH, HEIGHT, RED, GREEN, BLUE]
+
+=end
+
+# This sample app shows collisions between two boxes.
+
+# Runs methods needed for game to run properly.
+def tick args
+  tick_instructions args, "Sample app shows how to move a square over time and determine collision."
+  defaults args
+  render args
+  calc args
+end
+
+# Sets default values.
+def defaults args
+  # These values represent the moving box.
+  args.state.moving_box_speed   = 10
+  args.state.moving_box_size    = 100
+  args.state.moving_box_dx    ||=  1
+  args.state.moving_box_dy    ||=  1
+  args.state.moving_box       ||= [0, 0, args.state.moving_box_size, args.state.moving_box_size] # moving_box_size is set as the width and height
+
+  # These values represent the center box.
+  args.state.center_box ||= [540, 260, 200, 200, 180]
+  args.state.center_box_collision ||= false # initially no collision
+end
+
+def render args
+  # If the game state denotes that a collision has occured,
+  # render a solid square, otherwise render a border instead.
+  if args.state.center_box_collision
+    args.outputs.solids << args.state.center_box
+  else
+    args.outputs.borders << args.state.center_box
+  end
+
+  # Then render the moving box.
+  args.outputs.solids << args.state.moving_box
+end
+
+# Generally in a pipeline for a game engine, you have rendering,
+# game simulation (calculation), and input processing.
+# This fuction represents the game simulation.
+def calc args
+  position_moving_box args
+  determine_collision_center_box args
+end
+
+# Changes the position of the moving box on the screen by multiplying the change in x (dx) and change in y (dy) by the speed,
+# and adding it to the current position.
+# dx and dy are positive if the box is moving right and up, respectively
+# dx and dy are negative if the box is moving left and down, respectively
+def position_moving_box args
+  args.state.moving_box.x += args.state.moving_box_dx * args.state.moving_box_speed
+  args.state.moving_box.y += args.state.moving_box_dy * args.state.moving_box_speed
+
+  # 1280x720 are the virtual pixels you work with (essentially 720p).
+  screen_width  = 1280
+  screen_height = 720
+
+  # Position of the box is denoted by the bottom left hand corner, in
+  # that case, we have to subtract the width of the box so that it stays
+  # in the scene (you can try deleting the subtraction to see how it
+  # impacts the box's movement).
+  if args.state.moving_box.x > screen_width - args.state.moving_box_size
+    args.state.moving_box_dx = -1 # moves left
+  elsif args.state.moving_box.x < 0
+    args.state.moving_box_dx =  1 # moves right
+  end
+
+  # Here, we're making sure the moving box remains within the vertical scope of the screen
+  if args.state.moving_box.y > screen_height - args.state.moving_box_size # if the box moves too high
+    args.state.moving_box_dy = -1 # moves down
+  elsif args.state.moving_box.y < 0 # if the box moves too low
+    args.state.moving_box_dy =  1 # moves up
+  end
+end
+
+def determine_collision_center_box args
+  # Collision is handled by the engine. You simply have to call the
+  # `intersect_rect?` function.
+  if args.state.moving_box.intersect_rect? args.state.center_box # if the two boxes intersect
+    args.state.center_box_collision = true # then a collision happened
+  else
+    args.state.center_box_collision = false # otherwise, no collision happened
+  end
+end
+
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
+  end
+
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+end
+
+
+Physics And Collisions - Moving Objects - main.rb
+# ./samples/04_physics_and_collisions/02_moving_objects/app/main.rb
+=begin
+
+ APIs listing that haven't been encountered in previous sample apps:
+
+ - Hashes: Collection of unique keys and their corresponding values. The value can be found
+   using their keys.
+
+   For example, if we have a "numbers" hash that stores numbers in English as the
+   key and numbers in Spanish as the value, we'd have a hash that looks like this...
+   numbers = { "one" => "uno", "two" => "dos", "three" => "tres" }
+   and on it goes.
+
+   Now if we wanted to find the corresponding value of the "one" key, we could say
+   puts numbers["one"]
+   which would print "uno" to the console.
+
+ - num1.greater(num2): Returns the greater value.
+   For example, if we have the command
+   puts 4.greater(3)
+   the number 4 would be printed to the console since it has a greater value than 3.
+   Similar to lesser, which returns the lesser value.
+
+ - num1.lesser(num2): Finds the lower value of the given options.
+   For example, in the statement
+   a = 4.lesser(3)
+   3 has a lower value than 4, which means that the value of a would be set to 3,
+   but if the statement had been
+   a = 4.lesser(5)
+   4 has a lower value than 5, which means that the value of a would be set to 4.
+
+ - reject: Removes elements from a collection if they meet certain requirements.
+   For example, you can derive an array of odd numbers from an original array of
+   numbers 1 through 10 by rejecting all elements that are even (or divisible by 2).
+
+ - find_all: Finds all values that satisfy specific requirements.
+   For example, you can find all elements of a collection that are divisible by 2
+   or find all objects that have intersected with another object.
+
+ - abs: Returns the absolute value.
+   For example, the command
+   (-30).abs
+   would return 30 as a result.
+
+ - map: Ruby method used to transform data; used in arrays, hashes, and collections.
+   Can be used to perform an action on every element of a collection, such as multiplying
+   each element by 2 or declaring every element as a new entity.
+
+ Reminders:
+
+ - args.inputs.keyboard.KEY: Determines if a key has been pressed.
+   For more information about the keyboard, take a look at mygame/documentation/06-keyboard.md.
+
+ - ARRAY#intersect_rect?: Returns true or false depending on if the two rectangles intersect.
+
+ - args.outputs.solids: An array. The values generate a solid.
+   The parameters are [X, Y, WIDTH, HEIGHT, RED, GREEN, BLUE]
+   For more information about solids, go to mygame/documentation/03-solids-and-borders.md.
+
+=end
+
+# Calls methods needed for game to run properly
+def tick args
+  tick_instructions args, "Use LEFT and RIGHT arrow keys to move and SPACE to jump."
+  defaults args
+  render args
+  calc args
+  input args
+end
+
+# sets default values and creates empty collections
+# initialization only happens in the first frame
+def defaults args
+  fiddle args
+  args.state.enemy.hammers ||= []
+  args.state.enemy.hammer_queue ||= []
+  args.state.tick_count = args.state.tick_count
+  args.state.bridge_top = 128
+  args.state.player.x  ||= 0                        # initializes player's properties
+  args.state.player.y  ||= args.state.bridge_top
+  args.state.player.w  ||= 64
+  args.state.player.h  ||= 64
+  args.state.player.dy ||= 0
+  args.state.player.dx ||= 0
+  args.state.enemy.x   ||= 800                      # initializes enemy's properties
+  args.state.enemy.y   ||= 0
+  args.state.enemy.w   ||= 128
+  args.state.enemy.h   ||= 128
+  args.state.enemy.dy  ||= 0
+  args.state.enemy.dx  ||= 0
+  args.state.game_over_at ||= 0
+end
+
+# sets enemy, player, hammer values
+def fiddle args
+  args.state.gravity                     = -0.3
+  args.state.enemy_jump_power            = 10       # sets enemy values
+  args.state.enemy_jump_interval         = 60
+  args.state.hammer_throw_interval       = 40       # sets hammer values
+  args.state.hammer_launch_power_default = 5
+  args.state.hammer_launch_power_near    = 2
+  args.state.hammer_launch_power_far     = 7
+  args.state.hammer_upward_launch_power  = 15
+  args.state.max_hammers_per_volley      = 10
+  args.state.gap_between_hammers         = 10
+  args.state.player_jump_power           = 10       # sets player values
+  args.state.player_jump_power_duration  = 10
+  args.state.player_max_run_speed        = 10
+  args.state.player_speed_slowdown_rate  = 0.9
+  args.state.player_acceleration         = 1
+  args.state.hammer_size                 = 32
+end
+
+# outputs objects onto the screen
+def render args
+  args.outputs.solids << 20.map_with_index do |i| # uses 20 squares to form bridge
+    # sets x by multiplying 64 to index to find pixel value (places all squares side by side)
+    # subtracts 64 from bridge_top because position is denoted by bottom left corner
+    [i * 64, args.state.bridge_top - 64, 64, 64]
+  end
+
+  args.outputs.solids << [args.state.x, args.state.y, args.state.w, args.state.h, 255, 0, 0]
+  args.outputs.solids << [args.state.player.x, args.state.player.y, args.state.player.w, args.state.player.h, 255, 0, 0] # outputs player onto screen (red box)
+  args.outputs.solids << [args.state.enemy.x, args.state.enemy.y, args.state.enemy.w, args.state.enemy.h, 0, 255, 0] # outputs enemy onto screen (green box)
+  args.outputs.solids << args.state.enemy.hammers # outputs enemy's hammers onto screen
+end
+
+# Performs calculations to move objects on the screen
+def calc args
+
+  # Since velocity is the change in position, the change in x increases by dx. Same with y and dy.
+  args.state.player.x  += args.state.player.dx
+  args.state.player.y  += args.state.player.dy
+
+  # Since acceleration is the change in velocity, the change in y (dy) increases every frame
+  args.state.player.dy += args.state.gravity
+
+  # player's y position is either current y position or y position of top of
+  # bridge, whichever has a greater value
+  # ensures that the player never goes below the bridge
+  args.state.player.y  = args.state.player.y.greater(args.state.bridge_top)
+
+  # player's x position is either the current x position or 0, whichever has a greater value
+  # ensures that the player doesn't go too far left (out of the screen's scope)
+  args.state.player.x  = args.state.player.x.greater(0)
+
+  # player is not falling if it is located on the top of the bridge
+  args.state.player.falling = false if args.state.player.y == args.state.bridge_top
+  args.state.player.rect = [args.state.player.x, args.state.player.y, args.state.player.h, args.state.player.w] # sets definition for player
+
+  args.state.enemy.x += args.state.enemy.dx # velocity; change in x increases by dx
+  args.state.enemy.y += args.state.enemy.dy # same with y and dy
+
+  # ensures that the enemy never goes below the bridge
+  args.state.enemy.y  = args.state.enemy.y.greater(args.state.bridge_top)
+
+  # ensures that the enemy never goes too far left (outside the screen's scope)
+  args.state.enemy.x  = args.state.enemy.x.greater(0)
+
+  # objects that go up must come down because of gravity
+  args.state.enemy.dy += args.state.gravity
+
+  args.state.enemy.y  = args.state.enemy.y.greater(args.state.bridge_top)
+
+  #sets definition of enemy
+  args.state.enemy.rect = [args.state.enemy.x, args.state.enemy.y, args.state.enemy.h, args.state.enemy.w]
+
+  if args.state.enemy.y == args.state.bridge_top # if enemy is located on the top of the bridge
+    args.state.enemy.dy = 0 # there is no change in y
+  end
+
+  # if 60 frames have passed and the enemy is not moving vertically
+  if args.state.tick_count.mod_zero?(args.state.enemy_jump_interval) && args.state.enemy.dy == 0
+    args.state.enemy.dy = args.state.enemy_jump_power # the enemy jumps up
+  end
+
+  # if 40 frames have passed or 5 frames have passed since the game ended
+  if args.state.tick_count.mod_zero?(args.state.hammer_throw_interval) || args.state.game_over_at.elapsed_time == 5
+    # rand will return a number greater than or equal to 0 and less than given variable's value (since max is excluded)
+    # that is why we're adding 1, to include the max possibility
+    volley_dx   = (rand(args.state.hammer_launch_power_default) + 1) * -1 # horizontal movement (follow order of operations)
+
+    # if the horizontal distance between the player and enemy is less than 128 pixels
+    if (args.state.player.x - args.state.enemy.x).abs < 128
+      # the change in x won't be that great since the enemy and player are closer to each other
+      volley_dx = (rand(args.state.hammer_launch_power_near) + 1) * -1
+    end
+
+    # if the horizontal distance between the player and enemy is greater than 300 pixels
+    if (args.state.player.x - args.state.enemy.x).abs > 300
+      # change in x will be more drastic since player and enemy are so far apart
+      volley_dx = (rand(args.state.hammer_launch_power_far) + 1) * -1 # more drastic change
+    end
+
+    (rand(args.state.max_hammers_per_volley) + 1).map_with_index do |i|
+      args.state.enemy.hammer_queue << { # stores hammer values in a hash
+        x: args.state.enemy.x,
+        w: args.state.hammer_size,
+        h: args.state.hammer_size,
+        dx: volley_dx, # change in horizontal position
+        # multiplication operator takes precedence over addition operator
+        throw_at: args.state.tick_count + i * args.state.gap_between_hammers
+      }
+    end
+  end
+
+  # add elements from hammer_queue collection to the hammers collection by
+  # finding all hammers that were thrown before the current frame (have already been thrown)
+  args.state.enemy.hammers += args.state.enemy.hammer_queue.find_all do |h|
+    h[:throw_at] < args.state.tick_count
+  end
+
+  args.state.enemy.hammers.each do |h| # sets values for all hammers in collection
+    h[:y]  ||= args.state.enemy.y + 130
+    h[:dy] ||= args.state.hammer_upward_launch_power
+    h[:dy]  += args.state.gravity # acceleration is change in gravity
+    h[:x]   += h[:dx] # incremented by change in position
+    h[:y]   += h[:dy]
+    h[:rect] = [h[:x], h[:y], h[:w], h[:h]] # sets definition of hammer's rect
+  end
+
+  # reject hammers that have been thrown before current frame (have already been thrown)
+  args.state.enemy.hammer_queue = args.state.enemy.hammer_queue.reject do |h|
+    h[:throw_at] < args.state.tick_count
+  end
+
+  # any hammers with a y position less than 0 are rejected from the hammers collection
+  # since they have gone too far down (outside the scope's screen)
+  args.state.enemy.hammers = args.state.enemy.hammers.reject { |h| h[:y] < 0 }
+
+  # if there are any hammers that intersect with (or hit) the player,
+  # the reset_player method is called (so the game can start over)
+  if args.state.enemy.hammers.any? { |h| h[:rect].intersect_rect?(args.state.player.rect) }
+    reset_player args
+  end
+
+  # if the enemy's rect intersects with (or hits) the player,
+  # the reset_player method is called (so the game can start over)
+  if args.state.enemy.rect.intersect_rect? args.state.player.rect
+    reset_player args
+  end
+end
+
+# Resets the player by changing its properties back to the values they had at initialization
+def reset_player args
+  args.state.player.x = 0
+  args.state.player.y = args.state.bridge_top
+  args.state.player.dy = 0
+  args.state.player.dx = 0
+  args.state.enemy.hammers.clear # empties hammer collection
+  args.state.enemy.hammer_queue.clear # empties hammer_queue
+  args.state.game_over_at = args.state.tick_count # game_over_at set to current frame (or passage of time)
+end
+
+# Processes input from the user to move the player
+def input args
+  if args.inputs.keyboard.space # if the user presses the space bar
+    args.state.player.jumped_at ||= args.state.tick_count # jumped_at is set to current frame
+
+    # if the time that has passed since the jump is less than the player's jump duration and
+    # the player is not falling
+    if args.state.player.jumped_at.elapsed_time < args.state.player_jump_power_duration && !args.state.player.falling
+      args.state.player.dy = args.state.player_jump_power # change in y is set to power of player's jump
+    end
+  end
+
+  # if the space bar is in the "up" state (or not being pressed down)
+  if args.inputs.keyboard.key_up.space
+    args.state.player.jumped_at = nil # jumped_at is empty
+    args.state.player.falling = true # the player is falling
+  end
+
+  if args.inputs.keyboard.left # if left key is pressed
+    args.state.player.dx -= args.state.player_acceleration # dx decreases by acceleration (player goes left)
+    # dx is either set to current dx or the negative max run speed (which would be -10),
+    # whichever has a greater value
+    args.state.player.dx = args.state.player.dx.greater(-args.state.player_max_run_speed)
+  elsif args.inputs.keyboard.right # if right key is pressed
+    args.state.player.dx += args.state.player_acceleration # dx increases by acceleration (player goes right)
+    # dx is either set to current dx or max run speed (which would be 10),
+    # whichever has a lesser value
+    args.state.player.dx = args.state.player.dx.lesser(args.state.player_max_run_speed)
+  else
+    args.state.player.dx *= args.state.player_speed_slowdown_rate # dx is scaled down
+  end
+end
+
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.space ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
+  end
+
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+end
+
+
+Physics And Collisions - Entities - main.rb
+# ./samples/04_physics_and_collisions/03_entities/app/main.rb
+=begin
+
+ Reminders:
+
+ - map: Ruby method used to transform data; used in arrays, hashes, and collections.
+   Can be used to perform an action on every element of a collection, such as multiplying
+   each element by 2 or declaring every element as a new entity.
+
+ - reject: Removes elements from a collection if they meet certain requirements.
+   For example, you can derive an array of odd numbers from an original array of
+   numbers 1 through 10 by rejecting all elements that are even (or divisible by 2).
+
+ - args.state.new_entity: Used when we want to create a new object, like a sprite or button.
+   In this sample app, new_entity is used to define the properties of enemies and bullets.
+   (Remember, you can use state to define ANY property and it will be retained across frames.)
+
+ - args.outputs.labels: An array. The values generate a label on the screen.
+   The parameters are [X, Y, TEXT, SIZE, ALIGN, RED, GREEN, BLUE, ALPHA, FONT STYLE]
+
+ - ARRAY#intersect_rect?: Returns true or false depending on if the two rectangles intersect.
+
+ - args.inputs.mouse.click.point.(x|y): The x and y location of the mouse.
+
+=end
+
+# This sample app shows enemies that contain an id value and the time they were created.
+# These enemies can be removed by shooting at them with bullets.
+
+# Calls all methods necessary for the game to function properly.
+def tick args
+  tick_instructions args, "Sample app shows how to use args.state.new_entity along with collisions. CLICK to shoot a bullet."
+  defaults args
+  render args
+  calc args
+  process_inputs args
+end
+
+# Sets default values
+# Enemies and bullets start off as empty collections
+def defaults args
+  args.state.enemies ||= []
+  args.state.bullets ||= []
+end
+
+# Provides each enemy in enemies collection with rectangular border,
+# as well as a label showing id and when they were created
+def render args
+  # When you're calling a method that takes no arguments, you can use this & syntax on map.
+  # Numbers are being added to x and y in order to keep the text within the enemy's borders.
+  args.outputs.borders << args.state.enemies.map(&:rect)
+  args.outputs.labels  << args.state.enemies.flat_map do |enemy|
+    [
+      [enemy.x + 4, enemy.y + 29, "id: #{enemy.entity_id}", -3, 0],
+      [enemy.x + 4, enemy.y + 17, "created_at: #{enemy.created_at}", -3, 0] # frame enemy was created
+    ]
+  end
+
+  # Outputs bullets in bullets collection as rectangular solids
+  args.outputs.solids << args.state.bullets.map(&:rect)
+end
+
+# Calls all methods necessary for performing calculations
+def calc args
+  add_new_enemies_if_needed args
+  move_bullets args
+  calculate_collisions args
+  remove_bullets_of_screen args
+end
+
+# Adds enemies to the enemies collection and sets their values
+def add_new_enemies_if_needed args
+  return if args.state.enemies.length >= 10 # if 10 or more enemies, enemies are not added
+  return unless args.state.bullets.length == 0 # if user has not yet shot bullet, no enemies are added
+
+  args.state.enemies += (10 - args.state.enemies.length).map do # adds enemies so there are 10 total
+    args.state.new_entity(:enemy) do |e| # each enemy is declared as a new entity
+      e.x = 640 + 500 * rand # each enemy is given random position on screen
+      e.y = 600 * rand + 50
+      e.rect = [e.x, e.y, 130, 30] # sets definition for enemy's rect
+    end
+  end
+end
+
+# Moves bullets across screen
+# Sets definition of the bullets
+def move_bullets args
+  args.state.bullets.each do |bullet| # perform action on each bullet in collection
+    bullet.x += bullet.speed # increment x by speed (bullets fly horizontally across screen)
+
+    # By randomizing the value that increments bullet.y, the bullet does not fly straight up and out
+    # of the scope of the screen. Try removing what follows bullet.speed, or changing 0.25 to 1.25 to
+    # see what happens to the bullet's movement.
+    bullet.y += bullet.speed.*(0.25).randomize(:ratio, :sign)
+    bullet.rect = [bullet.x, bullet.y, bullet.size, bullet.size] # sets definition of bullet's rect
+  end
+end
+
+# Determines if a bullet hits an enemy
+def calculate_collisions args
+  args.state.bullets.each do |bullet| # perform action on every bullet and enemy in collections
+    args.state.enemies.each do |enemy|
+      # if bullet has not exploded yet and the bullet hits an enemy
+      if !bullet.exploded && bullet.rect.intersect_rect?(enemy.rect)
+        bullet.exploded = true # bullet explodes
+        enemy.dead = true # enemy is killed
+      end
+    end
+  end
+
+  # All exploded bullets are rejected or removed from the bullets collection
+  # and any dead enemy is rejected from the enemies collection.
+  args.state.bullets = args.state.bullets.reject(&:exploded)
+  args.state.enemies = args.state.enemies.reject(&:dead)
+end
+
+# Bullets are rejected from bullets collection once their position exceeds the width of screen
+def remove_bullets_of_screen args
+  args.state.bullets = args.state.bullets.reject { |bullet| bullet.x > 1280 } # screen width is 1280
+end
+
+# Calls fire_bullet method
+def process_inputs args
+  fire_bullet args
+end
+
+# Once mouse is clicked by the user to fire a bullet, a new bullet is added to bullets collection
+def fire_bullet args
+  return unless args.inputs.mouse.click # return unless mouse is clicked
+  args.state.bullets << args.state.new_entity(:bullet) do |bullet| # new bullet is declared a new entity
+    bullet.y = args.inputs.mouse.click.point.y # set to the y value of where the mouse was clicked
+    bullet.x = 0 # starts on the left side of the screen
+    bullet.size = 10
+    bullet.speed = 10 * rand + 2 # speed of a bullet is randomized
+    bullet.rect = [bullet.x, bullet.y, bullet.size, bullet.size] # definition is set
+  end
+end
+
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.space ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
+  end
+
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+end
+
+
+Physics And Collisions - Box Collision - main.rb
+# ./samples/04_physics_and_collisions/04_box_collision/app/main.rb
+=begin
+
+ APIs listing that haven't been encountered in previous sample apps:
+
+ - first: Returns the first element of the array.
+   For example, if we have an array
+   numbers = [1, 2, 3, 4, 5]
+   and we call first by saying
+   numbers.first
+   the number 1 will be returned because it is the first element of the numbers array.
+
+ - num1.idiv(num2): Divides two numbers and returns an integer.
+   For example,
+   16.idiv(3) = 5, because 16 / 3 is 5.33333 returned as an integer.
+   16.idiv(4) = 4, because 16 / 4 is 4 and already has no decimal.
+
+ Reminders:
+
+ - find_all: Finds all values that satisfy specific requirements.
+
+ - ARRAY#intersect_rect?: An array with at least four values is
+   considered a rect. The intersect_rect? function returns true
+   or false depending on if the two rectangles intersect.
+
+ - reject: Removes elements from a collection if they meet certain requirements.
+
+=end
+
+# This sample app allows users to create tiles and place them anywhere on the screen as obstacles.
+# The player can then move and maneuver around them.
+
+class PoorManPlatformerPhysics
+  attr_accessor :grid, :inputs, :state, :outputs
+
+  # Calls all methods necessary for the app to run successfully.
+  def tick
+    defaults
+    render
+    calc
+    process_inputs
+  end
+
+  # Sets default values for variables.
+  # The ||= sign means that the variable will only be set to the value following the = sign if the value has
+  # not already been set before. Intialization happens only in the first frame.
+  def defaults
+    state.tile_size               = 64
+    state.gravity                 = -0.2
+    state.previous_tile_size    ||= state.tile_size
+    state.x                     ||= 0
+    state.y                     ||= 800
+    state.dy                    ||= 0
+    state.dx                    ||= 0
+    state.world                 ||= []
+    state.world_lookup          ||= {}
+    state.world_collision_rects ||= []
+  end
+
+  # Outputs solids and borders of different colors for the world and collision_rects collections.
+  def render
+
+    # Sets a black background on the screen (Comment this line out and the background will become white.)
+    # Also note that black is the default color for when no color is assigned.
+    outputs.solids << grid.rect
+
+    # The position, size, and color (white) are set for borders given to the world collection.
+    # Try changing the color by assigning different numbers (between 0 and 255) to the last three parameters.
+    outputs.borders << state.world.map do |x, y|
+      [x * state.tile_size,
+       y * state.tile_size,
+       state.tile_size,
+       state.tile_size, 255, 255, 255]
+    end
+
+    # The top, bottom, and sides of the borders for collision_rects are different colors.
+    outputs.borders << state.world_collision_rects.map do |e|
+      [
+        [e[:top],                             0, 170,   0], # top is a shade of green
+        [e[:bottom],                          0, 100, 170], # bottom is a shade of greenish-blue
+        [e[:left_right],                    170,   0,   0], # left and right are a shade of red
+      ]
+    end
+
+    # Sets the position, size, and color (a shade of green) of the borders of only the player's
+    # box and outputs it. If you change the 180 to 0, the player's box will be black and you
+    # won't be able to see it (because it will match the black background).
+    outputs.borders << [state.x,
+                        state.y,
+                        state.tile_size,
+                        state.tile_size,  0, 180, 0]
+  end
+
+  # Calls methods needed to perform calculations.
+  def calc
+    calc_world_lookup
+    calc_player
+  end
+
+  # Performs calculations on world_lookup and sets values.
+  def calc_world_lookup
+
+    # If the tile size isn't equal to the previous tile size,
+    # the previous tile size is set to the tile size,
+    # and world_lookup hash is set to empty.
+    if state.tile_size != state.previous_tile_size
+      state.previous_tile_size = state.tile_size
+      state.world_lookup = {} # empty hash
+    end
+
+    # return if the world_lookup hash has keys (or, in other words, is not empty)
+    # return unless the world collection has values inside of it (or is not empty)
+    return if state.world_lookup.keys.length > 0
+    return unless state.world.length > 0
+
+    # Starts with an empty hash for world_lookup.
+    # Searches through the world and finds the coordinates that exist.
+    state.world_lookup = {}
+    state.world.each { |x, y| state.world_lookup[[x, y]] = true }
+
+    # Assigns world_collision_rects for every sprite drawn.
+    state.world_collision_rects =
+      state.world_lookup
+          .keys
+          .map do |coord_x, coord_y|
+            s = state.tile_size
+            # multiply by tile size so the grid coordinates; sets pixel value
+            # don't forget that position is denoted by bottom left corner
+            # set x = coord_x or y = coord_y and see what happens!
+            x = s * coord_x
+            y = s * coord_y
+            {
+              # The values added to x, y, and s position the world_collision_rects so they all appear
+              # stacked (on top of world rects) but don't directly overlap.
+              # Remove these added values and mess around with the rect placement!
+              args:       [coord_x, coord_y],
+              left_right: [x,     y + 4, s,     s - 6], # hash keys and values
+              top:        [x + 4, y + 6, s - 8, s - 6],
+              bottom:     [x + 1, y - 1, s - 2, s - 8],
+            }
+          end
+  end
+
+  # Performs calculations to change the x and y values of the player's box.
+  def calc_player
+
+    # Since acceleration is the change in velocity, the change in y (dy) increases every frame.
+    # What goes up must come down because of gravity.
+    state.dy += state.gravity
+
+    # Calls the calc_box_collision and calc_edge_collision methods.
+    calc_box_collision
+    calc_edge_collision
+
+    # Since velocity is the change in position, the change in y increases by dy. Same with x and dx.
+    state.y += state.dy
+    state.x += state.dx
+
+    # Scales dx down.
+    state.dx *= 0.8
+  end
+
+  # Calls methods needed to determine collisions between player and world_collision rects.
+  def calc_box_collision
+    return unless state.world_lookup.keys.length > 0 # return unless hash has atleast 1 key
+    collision_floor!
+    collision_left!
+    collision_right!
+    collision_ceiling!
+  end
+
+  # Finds collisions between the bottom of the player's rect and the top of a world_collision_rect.
+  def collision_floor!
+    return unless state.dy <= 0 # return unless player is going down or is as far down as possible
+    player_rect = [state.x, state.y - 0.1, state.tile_size, state.tile_size] # definition of player
+
+    # Goes through world_collision_rects to find all intersections between the bottom of player's rect and
+    # the top of a world_collision_rect (hence the "-0.1" above)
+    floor_collisions = state.world_collision_rects
+                           .find_all { |r| r[:top].intersect_rect?(player_rect, collision_tollerance) }
+                           .first
+
+    return unless floor_collisions # return unless collision occurred
+    state.y = floor_collisions[:top].top # player's y is set to the y of the top of the collided rect
+    state.dy = 0 # if a collision occurred, the player's rect isn't moving because its path is blocked
+  end
+
+  # Finds collisions between the player's left side and the right side of a world_collision_rect.
+  def collision_left!
+    return unless state.dx < 0 # return unless player is moving left
+    player_rect = [state.x - 0.1, state.y, state.tile_size, state.tile_size]
+
+    # Goes through world_collision_rects to find all intersections beween the player's left side and the
+    # right side of a world_collision_rect.
+    left_side_collisions = state.world_collision_rects
+                               .find_all { |r| r[:left_right].intersect_rect?(player_rect, collision_tollerance) }
+                               .first
+
+    return unless left_side_collisions # return unless collision occurred
+
+    # player's x is set to the value of the x of the collided rect's right side
+    state.x = left_side_collisions[:left_right].right
+    state.dx = 0 # player isn't moving left because its path is blocked
+  end
+
+  # Finds collisions between the right side of the player and the left side of a world_collision_rect.
+  def collision_right!
+    return unless state.dx > 0 # return unless player is moving right
+    player_rect = [state.x + 0.1, state.y, state.tile_size, state.tile_size]
+
+    # Goes through world_collision_rects to find all intersections between the player's right side
+    # and the left side of a world_collision_rect (hence the "+0.1" above)
+    right_side_collisions = state.world_collision_rects
+                                .find_all { |r| r[:left_right].intersect_rect?(player_rect, collision_tollerance) }
+                                .first
+
+    return unless right_side_collisions # return unless collision occurred
+
+    # player's x is set to the value of the collided rect's left, minus the size of a rect
+    # tile size is subtracted because player's position is denoted by bottom left corner
+    state.x = right_side_collisions[:left_right].left - state.tile_size
+    state.dx = 0 # player isn't moving right because its path is blocked
+  end
+
+  # Finds collisions between the top of the player's rect and the bottom of a world_collision_rect.
+  def collision_ceiling!
+    return unless state.dy > 0 # return unless player is moving up
+    player_rect = [state.x, state.y + 0.1, state.tile_size, state.tile_size]
+
+    # Goes through world_collision_rects to find intersections between the bottom of a
+    # world_collision_rect and the top of the player's rect (hence the "+0.1" above)
+    ceil_collisions = state.world_collision_rects
+                          .find_all { |r| r[:bottom].intersect_rect?(player_rect, collision_tollerance) }
+                          .first
+
+    return unless ceil_collisions # return unless collision occurred
+
+    # player's y is set to the bottom y of the rect it collided with, minus the size of a rect
+    state.y = ceil_collisions[:bottom].y - state.tile_size
+    state.dy = 0 # if a collision occurred, the player isn't moving up because its path is blocked
+  end
+
+  # Makes sure the player remains within the screen's dimensions.
+  def calc_edge_collision
+
+    #Ensures that the player doesn't fall below the map.
+    if state.y < 0
+      state.y = 0
+      state.dy = 0
+
+    #Ensures that the player doesn't go too high.
+    # Position of player is denoted by bottom left hand corner, which is why we have to subtract the
+    # size of the player's box (so it remains visible on the screen)
+    elsif state.y > 720 - state.tile_size # if the player's y position exceeds the height of screen
+      state.y = 720 - state.tile_size # the player will remain as high as possible while staying on screen
+      state.dy = 0
+    end
+
+    # Ensures that the player remains in the horizontal range that it is supposed to.
+    if state.x >= 1280 - state.tile_size && state.dx > 0 # if player moves too far right
+      state.x = 1280 - state.tile_size # player will remain as right as possible while staying on screen
+      state.dx = 0
+    elsif state.x <= 0 && state.dx < 0 # if player moves too far left
+      state.x = 0 # player will remain as left as possible while remaining on screen
+      state.dx = 0
+    end
+  end
+
+  # Processes input from the user on the keyboard.
+  def process_inputs
+    if inputs.mouse.down
+      state.world_lookup = {}
+      x, y = to_coord inputs.mouse.down.point  # gets x, y coordinates for the grid
+
+      if state.world.any? { |loc| loc == [x, y] }  # checks if coordinates duplicate
+        state.world = state.world.reject { |loc| loc == [x, y] }  # erases tile space
+      else
+        state.world << [x, y] # If no duplicates, adds to world collection
+      end
+    end
+
+    # Sets dx to 0 if the player lets go of arrow keys.
+    if inputs.keyboard.key_up.right
+      state.dx = 0
+    elsif inputs.keyboard.key_up.left
+      state.dx = 0
+    end
+
+    # Sets dx to 3 in whatever direction the player chooses.
+    if inputs.keyboard.key_held.right # if right key is pressed
+      state.dx =  3
+    elsif inputs.keyboard.key_held.left # if left key is pressed
+      state.dx = -3
+    end
+
+    #Sets dy to 5 to make the player ~fly~ when they press the space bar
+    if inputs.keyboard.key_held.space
+      state.dy = 5
+    end
+  end
+
+  def to_coord point
+
+    # Integer divides (idiv) point.x to turn into grid
+    # Then, you can just multiply each integer by state.tile_size later so the grid coordinates.
+    [point.x.idiv(state.tile_size), point.y.idiv(state.tile_size)]
+  end
+
+  # Represents the tolerance for a collision between the player's rect and another rect.
+  def collision_tollerance
+    0.0
+  end
+end
+
+$platformer_physics = PoorManPlatformerPhysics.new
+
+def tick args
+  $platformer_physics.grid    = args.grid
+  $platformer_physics.inputs  = args.inputs
+  $platformer_physics.state    = args.state
+  $platformer_physics.outputs = args.outputs
+  $platformer_physics.tick
+  tick_instructions args, "Sample app shows platformer collisions. CLICK to place box. ARROW keys to move around. SPACE to jump."
+end
+
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
+  end
+
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+end
+
+
+Physics And Collisions - Box Collision 2 - main.rb
+# ./samples/04_physics_and_collisions/05_box_collision_2/app/main.rb
+=begin
+ APIs listing that haven't been encountered in previous sample apps:
+
+ - times: Performs an action a specific number of times.
+   For example, if we said
+   5.times puts "Hello DragonRuby",
+   then we'd see the words "Hello DragonRuby" printed on the console 5 times.
+
+ - split: Divides a string into substrings based on a delimiter.
+   For example, if we had a command
+   "DragonRuby is awesome".split(" ")
+   then the result would be
+   ["DragonRuby", "is", "awesome"] because the words are separated by a space delimiter.
+
+ - join: Opposite of split; converts each element of array to a string separated by delimiter.
+   For example, if we had a command
+   ["DragonRuby","is","awesome"].join(" ")
+   then the result would be
+   "DragonRuby is awesome".
+
+ Reminders:
+
+ - to_s: Returns a string representation of an object.
+   For example, if we had
+   500.to_s
+   the string "500" would be returned.
+   Similar to to_i, which returns an integer representation of an object.
+
+ - elapsed_time: How many frames have passed since the click event.
+
+ - args.outputs.labels: An array. Values in the array generate labels on the screen.
+   The parameters are: [X, Y, TEXT, SIZE, ALIGN, RED, GREEN, BLUE, ALPHA, FONT STYLE]
+   For more information about labels, go to mygame/documentation/02-labels.md.
+
+ - inputs.mouse.down: Determines whether or not the mouse is being pressed down.
+   The position of the mouse when it is pressed down can be found using inputs.mouse.down.point.(x|y).
+
+ - first: Returns the first element of the array.
+
+ - num1.idiv(num2): Divides two numbers and returns an integer.
+
+ - find_all: Finds all values that satisfy specific requirements.
+
+ - ARRAY#intersect_rect?: Returns true or false depending on if two rectangles intersect.
+
+ - reject: Removes elements from a collection if they meet certain requirements.
+
+ - String interpolation: Uses #{} syntax; everything between the #{ and the } is evaluated
+   as Ruby code, and the placeholder is replaced with its corresponding value or result.
+
+=end
+
+MAP_FILE_PATH = 'app/map.txt' # the map.txt file in the app folder contains exported map
+
+class MetroidvaniaStarter
+  attr_accessor :grid, :inputs, :state, :outputs, :gtk
+
+  # Calls methods needed to run the game properly.
+  def tick
+    defaults
+    render
+    calc
+    process_inputs
+  end
+
+  # Sets all the default variables.
+  # '||' states that initialization occurs only in the first frame.
+  def defaults
+    state.tile_size                = 64
+    state.gravity                  = -0.2
+    state.player_width             = 60
+    state.player_height            = 64
+    state.collision_tolerance      = 0.0
+    state.previous_tile_size     ||= state.tile_size
+    state.x                      ||= 0
+    state.y                      ||= 800
+    state.dy                     ||= 0
+    state.dx                     ||= 0
+    attempt_load_world_from_file
+    state.world_lookup           ||= { }
+    state.world_collision_rects  ||= []
+    state.mode                   ||= :creating # alternates between :creating and :selecting for sprite selection
+    state.select_menu            ||= [0, 720, 1280, 720]
+    #=======================================IMPORTANT=======================================#
+    # When adding sprites, please label them "image1.png", "image2.png", image3".png", etc.
+    # Once you have done that, adjust "state.sprite_quantity" to how many sprites you have.
+    #=======================================================================================#
+    state.sprite_quantity        ||= 20 # IMPORTANT TO ALTER IF SPRITES ADDED IF YOU ADD MORE SPRITES
+    state.sprite_coords          ||= []
+    state.banner_coords          ||= [640, 680 + 720]
+    state.sprite_selected        ||= 1
+    state.map_saved_at           ||= 0
+
+    # Sets all the cordinate values for the sprite selection screen into a grid
+    # Displayed when 's' is pressed by player to access sprites
+    if state.sprite_coords == [] # if sprite_coords is an empty array
+      count = 1
+      temp_x = 165 # sets a starting x and y position for display
+      temp_y = 500 + 720
+      state.sprite_quantity.times do # for the number of sprites you have
+        state.sprite_coords += [[temp_x, temp_y, count]] # add element to sprite_coords array
+        temp_x += 100 # increment temp_x
+        count += 1 # increment count
+        if temp_x > 1280 - (165 + 50) # if exceeding specific horizontal width on screen
+          temp_x = 165 # a new row of sprites starts
+          temp_y -= 75 # new row of sprites starts 75 units lower than the previous row
+        end
+      end
+    end
+  end
+
+  # Places sprites
+  def render
+
+    # Sets the x, y, width, height, and image path for each sprite in the world collection.
+    outputs.sprites << state.world.map do |x, y, sprite|
+      [x * state.tile_size, # multiply by size so grid coordinates; pixel value of location
+       y * state.tile_size,
+       state.tile_size,
+       state.tile_size,
+       'sprites/image' + sprite.to_s + '.png'] # uses concatenation to create unique image path
+    end
+
+    # Outputs sprite for the player by setting x, y, width, height, and image path
+    outputs.sprites << [state.x,
+                        state.y,
+                        state.player_width,
+                        state.player_height,'sprites/player.png']
+
+    # Outputs labels as primitives in top right of the screen
+    outputs.primitives << [920, 700, 'Press \'s\' to access sprites.', 1, 0].label
+    outputs.primitives << [920, 675, 'Click existing sprite to delete.', 1, 0].label
+
+    outputs.primitives << [920, 640, '<- and -> to move.', 1, 0].label
+    outputs.primitives << [920, 615, 'Press and hold space to jump.', 1, 0].label
+
+    outputs.primitives << [920, 580, 'Press \'e\' to export current map.', 1, 0].label
+
+    # if the map is saved and less than 120 frames have passed, the label is displayed
+    if state.map_saved_at > 0 && state.map_saved_at.elapsed_time < 120
+      outputs.primitives << [920, 555, 'Map has been exported!', 1, 0, 50, 100, 50].label
+    end
+
+    # If player hits 's', following appears
+    if state.mode == :selecting
+      # White background for sprite selection
+      outputs.primitives << [state.select_menu, 255, 255, 255].solid
+
+      # Select tile label at the top of the screen
+      outputs.primitives << [state.banner_coords.x, state.banner_coords.y, "Select Sprite (sprites located in \"sprites\" folder)", 10, 1, 0, 0, 0, 255].label
+
+      # Places sprites in locations calculated in the defaults function
+      outputs.primitives << state.sprite_coords.map do |x, y, order|
+        [x, y, 50, 50, 'sprites/image' + order.to_s + ".png"].sprite
+      end
+    end
+
+    # Creates sprite following mouse to help indicate which sprite you have selected
+    # 10 is subtracted from the mouse's x position so that the sprite is not covered by the mouse icon
+    outputs.primitives << [inputs.mouse.position.x - 10, inputs.mouse.position.y,
+                           10, 10, 'sprites/image' + state.sprite_selected.to_s + ".png"].sprite
+  end
+
+  # Calls methods that perform calculations
+  def calc
+    calc_in_game
+    calc_sprite_selection
+  end
+
+  # Calls methods that perform calculations (if in creating mode)
+  def calc_in_game
+    return unless state.mode == :creating
+    calc_world_lookup
+    calc_player
+  end
+
+  def calc_world_lookup
+    # If the tile size isn't equal to the previous tile size,
+    # the previous tile size is set to the tile size,
+    # and world_lookup hash is set to empty.
+    if state.tile_size != state.previous_tile_size
+      state.previous_tile_size = state.tile_size
+      state.world_lookup = {}
+    end
+
+    # return if world_lookup is not empty or if world is empty
+    return if state.world_lookup.keys.length > 0
+    return unless state.world.length > 0
+
+    # Searches through the world and finds the coordinates that exist
+    state.world_lookup = {}
+    state.world.each { |x, y| state.world_lookup[[x, y]] = true }
+
+    # Assigns collision rects for every sprite drawn
+    state.world_collision_rects =
+      state.world_lookup
+           .keys
+           .map do |coord_x, coord_y|
+             s = state.tile_size
+             # Multiplying by s (the size of a tile) ensures that the rect is
+             # placed exactly where you want it to be placed (causes grid to coordinate)
+             # How many pixels horizontally across and vertically up and down
+             x = s * coord_x
+             y = s * coord_y
+             {
+               args:       [coord_x, coord_y],
+               left_right: [x,     y + 4, s,     s - 6], # hash keys and values
+               top:        [x + 4, y + 6, s - 8, s - 6],
+               bottom:     [x + 1, y - 1, s - 2, s - 8],
+             }
+           end
+  end
+
+  # Calculates movement of player and calls methods that perform collision calculations
+  def calc_player
+    state.dy += state.gravity  # what goes up must come down because of gravity
+    calc_box_collision
+    calc_edge_collision
+    state.y  += state.dy       # Since velocity is the change in position, the change in y increases by dy
+    state.x  += state.dx       # Ditto line above but dx and x
+    state.dx *= 0.8            # Scales dx down
+  end
+
+  # Calls methods that determine whether the player collides with any world_collision_rects.
+  def calc_box_collision
+    return unless state.world_lookup.keys.length > 0 # return unless hash has atleast 1 key
+    collision_floor
+    collision_left
+    collision_right
+    collision_ceiling
+  end
+
+  # Finds collisions between the bottom of the player's rect and the top of a world_collision_rect.
+  def collision_floor
+    return unless state.dy <= 0 # return unless player is going down or is as far down as possible
+    player_rect = [state.x, next_y, state.tile_size, state.tile_size] # definition of player
+
+    # Runs through all the sprites on the field and finds all intersections between player's
+    # bottom and the top of a rect.
+    floor_collisions = state.world_collision_rects
+                         .find_all { |r| r[:top].intersect_rect?(player_rect, state.collision_tolerance) }
+                         .first
+
+    return unless floor_collisions # performs following changes if a collision has occurred
+    state.y = floor_collisions[:top].top # y of player is set to the y of the colliding rect's top
+    state.dy = 0 # no change in y because the player's path is blocked
+  end
+
+  # Finds collisions between the player's left side and the right side of a world_collision_rect.
+  def collision_left
+    return unless state.dx < 0 # return unless player is moving left
+    player_rect = [next_x, state.y, state.tile_size, state.tile_size]
+
+    # Runs through all the sprites on the field and finds all intersections between the player's left side
+    # and the right side of a rect.
+    left_side_collisions = state.world_collision_rects
+                             .find_all { |r| r[:left_right].intersect_rect?(player_rect, state.collision_tolerance) }
+                             .first
+
+    return unless left_side_collisions # return unless collision occurred
+    state.x = left_side_collisions[:left_right].right # sets player's x to the x of the colliding rect's right side
+    state.dx = 0 # no change in x because the player's path is blocked
+  end
+
+  # Finds collisions between the right side of the player and the left side of a world_collision_rect.
+  def collision_right
+    return unless state.dx > 0 # return unless player is moving right
+    player_rect = [next_x, state.y, state.tile_size, state.tile_size]
+
+    # Runs through all the sprites on the field and finds all intersections between the  player's
+    # right side and the left side of a rect.
+    right_side_collisions = state.world_collision_rects
+                              .find_all { |r| r[:left_right].intersect_rect?(player_rect, state.collision_tolerance) }
+                              .first
+
+    return unless right_side_collisions # return unless collision occurred
+    state.x = right_side_collisions[:left_right].left - state.tile_size # player's x is set to the x of colliding rect's left side (minus tile size since x is the player's bottom left corner)
+    state.dx = 0 # no change in x because the player's path is blocked
+  end
+
+  # Finds collisions between the top of the player's rect and the bottom of a world_collision_rect.
+  def collision_ceiling
+    return unless state.dy > 0 # return unless player is moving up
+    player_rect = [state.x, next_y, state.player_width, state.player_height]
+
+    # Runs through all the sprites on the field and finds all intersections between the player's top
+    # and the bottom of a rect.
+    ceil_collisions = state.world_collision_rects
+                        .find_all { |r| r[:bottom].intersect_rect?(player_rect, state.collision_tolerance) }
+                        .first
+
+    return unless ceil_collisions # return unless collision occurred
+    state.y = ceil_collisions[:bottom].y - state.tile_size # player's y is set to the y of the colliding rect's bottom (minus tile size)
+    state.dy = 0 # no change in y because the player's path is blocked
+  end
+
+  # Makes sure the player remains within the screen's dimensions.
+  def calc_edge_collision
+    # Ensures that player doesn't fall below the map
+    if next_y < 0 && state.dy < 0 # if player is moving down and is about to fall (next_y) below the map's scope
+      state.y = 0 # 0 is the lowest the player can be while staying on the screen
+      state.dy = 0
+    # Ensures player doesn't go insanely high
+    elsif next_y > 720 - state.tile_size && state.dy > 0 # if player is moving up, about to exceed map's scope
+      state.y = 720 - state.tile_size # if we don't subtract tile_size, we won't be able to see the player on the screen
+      state.dy = 0
+    end
+
+    # Ensures that player remains in the horizontal range its supposed to
+    if state.x >= 1280 - state.tile_size && state.dx > 0 # if the player is moving too far right
+      state.x = 1280 - state.tile_size # farthest right the player can be while remaining in the screen's scope
+      state.dx = 0
+    elsif state.x <= 0 && state.dx < 0 # if the player is moving too far left
+      state.x = 0 # farthest left the player can be while remaining in the screen's scope
+      state.dx = 0
+    end
+  end
+
+  def calc_sprite_selection
+    # Does the transition to bring down the select sprite screen
+    if state.mode == :selecting && state.select_menu.y != 0
+      state.select_menu.y = 0  # sets y position of select menu (shown when 's' is pressed)
+      state.banner_coords.y = 680 # sets y position of Select Sprite banner
+      state.sprite_coords = state.sprite_coords.map do |x, y, w, h|
+        [x, y - 720, w, h] # sets definition of sprites (change '-' to '+' and the sprites can't be seen)
+      end
+    end
+
+    # Does the transition to leave the select sprite screen
+    if state.mode == :creating  && state.select_menu.y != 720
+      state.select_menu.y = 720 # sets y position of select menu (menu is retreated back up)
+      state.banner_coords.y = 1000 # sets y position of Select Sprite banner
+      state.sprite_coords = state.sprite_coords.map do |x, y, w, h|
+        [x, y + 720, w, h] # sets definition of all elements in collection
+      end
+    end
+  end
+
+  def process_inputs
+    # If the state.mode is back and if the menu has retreated back up
+    # call methods that process user inputs
+    if state.mode == :creating
+      process_inputs_player_movement
+      process_inputs_place_tile
+    end
+
+    # For each sprite_coordinate added, check what sprite was selected
+    if state.mode == :selecting
+      state.sprite_coords.map do |x, y, order| # goes through all sprites in collection
+        # checks that a specific sprite was pressed based on x, y position
+        if inputs.mouse.down && # the && (and) sign means ALL statements must be true for the evaluation to be true
+           inputs.mouse.down.point.x >= x      && # x is greater than or equal to sprite's x and
+           inputs.mouse.down.point.x <= x + 50 && # x is less than or equal to 50 pixels to the right
+           inputs.mouse.down.point.y >= y      && # y is greater than or equal to sprite's y
+           inputs.mouse.down.point.y <= y + 50 # y is less than or equal to 50 pixels up
+          state.sprite_selected = order # sprite is chosen
+        end
+      end
+    end
+
+    inputs_export_stage
+    process_inputs_show_available_sprites
+  end
+
+  # Moves the player based on the keys they press on their keyboard
+  def process_inputs_player_movement
+    # Sets dx to 0 if the player lets go of arrow keys (player won't move left or right)
+    if inputs.keyboard.key_up.right
+      state.dx = 0
+    elsif inputs.keyboard.key_up.left
+      state.dx = 0
+    end
+
+    # Sets dx to 3 in whatever direction the player chooses when they hold down (or press) the left or right keys
+    if inputs.keyboard.key_held.right
+      state.dx =  3
+    elsif inputs.keyboard.key_held.left
+      state.dx = -3
+    end
+
+    # Sets dy to 5 to make the player ~fly~ when they press the space bar on their keyboard
+    if inputs.keyboard.key_held.space
+      state.dy = 5
+    end
+  end
+
+  # Adds tile in the place the user holds down the mouse
+  def process_inputs_place_tile
+    if inputs.mouse.down # if mouse is pressed
+      state.world_lookup = {}
+      x, y = to_coord inputs.mouse.down.point # gets x, y coordinates for the grid
+
+      # Checks if any coordinates duplicate (already exist in world)
+      if state.world.any? { |existing_x, existing_y, n| existing_x == x && existing_y == y }
+        #erases existing tile space by rejecting them from world
+        state.world = state.world.reject do |existing_x, existing_y, n|
+          existing_x == x && existing_y == y
+        end
+      else
+        state.world << [x, y, state.sprite_selected] # If no duplicates, add the sprite
+      end
+    end
+  end
+
+  # Stores/exports world collection's info (coordinates, sprite number) into a file
+  def inputs_export_stage
+    if inputs.keyboard.key_down.e # if "e" is pressed
+      export_string = state.world.map do |x, y, sprite_number| # stores world info in a string
+        "#{x},#{y},#{sprite_number}"                           # using string interpolation
+      end
+      gtk.write_file(MAP_FILE_PATH, export_string.join("\n")) # writes string into a file
+      state.map_saved_at = state.tick_count # frame number (passage of time) when the map was saved
+    end
+  end
+
+  def process_inputs_show_available_sprites
+    # Based on keyboard input, the entity (:creating and :selecting) switch
+    if inputs.keyboard.key_held.s && state.mode == :creating # if "s" is pressed and currently creating
+      state.mode = :selecting # will change to selecting
+      inputs.keyboard.clear # VERY IMPORTANT! If not present, it'll flicker between on and off
+    elsif inputs.keyboard.key_held.s && state.mode == :selecting # if "s" is pressed and currently selecting
+      state.mode = :creating # will change to creating
+      inputs.keyboard.clear # VERY IMPORTANT! If not present, it'll flicker between on and off
+    end
+  end
+
+  # Loads the world collection by reading from the map.txt file in the app folder
+  def attempt_load_world_from_file
+    return if state.world # return if the world collection is already populated
+    state.world ||= [] # initialized as an empty collection
+    exported_world = gtk.read_file(MAP_FILE_PATH) # reads the file using the path mentioned at top of code
+    return unless exported_world # return unless the file read was successful
+    state.world = exported_world.each_line.map do |l| # perform action on each line of exported_world
+        l.split(',').map(&:to_i) # calls split using ',' as a delimiter, and invokes .map on the collection,
+                                 # calling to_i (converts to integers) on each element
+    end
+  end
+
+  # Adds the change in y to y to determine the next y position of the player.
+  def next_y
+    state.y + state.dy
+  end
+
+  # Determines next x position of player
+  def next_x
+    if state.dx < 0 # if the player moves left
+      return state.x - (state.tile_size - state.player_width) # subtracts since the change in x is negative (player is moving left)
+    else
+      return state.x + (state.tile_size - state.player_width) # adds since the change in x is positive (player is moving right)
+    end
+  end
+
+  def to_coord point
+    # Integer divides (idiv) point.x to turn into grid
+    # Then, you can just multiply each integer by state.tile_size
+    # later and huzzah. Grid coordinates
+    [point.x.idiv(state.tile_size), point.y.idiv(state.tile_size)]
+  end
+end
+
+$metroidvania_starter = MetroidvaniaStarter.new
+
+def tick args
+    $metroidvania_starter.grid    = args.grid
+    $metroidvania_starter.inputs  = args.inputs
+    $metroidvania_starter.state   = args.state
+    $metroidvania_starter.outputs = args.outputs
+    $metroidvania_starter.gtk     = args.gtk
+    $metroidvania_starter.tick
+end
+
+
+Physics And Collisions - Box Collision 3 - main.rb
+# ./samples/04_physics_and_collisions/06_box_collision_3/app/main.rb
+class Game
+  attr_gtk
+
+  def tick
+    defaults
+    render
+    input_edit_map
+    input_player
+    calc_player
+  end
+
+  def defaults
+    state.gravity           = -0.4
+    state.drag              = 0.15
+    state.tile_size         = 32
+    state.player.size       = 16
+    state.player.jump_power = 12
+
+    state.tiles                 ||= []
+    state.player.y              ||= 800
+    state.player.x              ||= 100
+    state.player.dy             ||= 0
+    state.player.dx             ||= 0
+    state.player.jumped_down_at ||= 0
+    state.player.jumped_at      ||= 0
+
+    calc_player_rect if !state.player.rect
+  end
+
+  def render
+    outputs.labels << [10, 10.from_top, "tile: click to add a tile, hold X key and click to delete a tile."]
+    outputs.labels << [10, 35.from_top, "move: use left and right to move, space to jump, down and space to jump down."]
+    outputs.labels << [10, 55.from_top, "      You can jump through or jump down through tiles with a height of 1."]
+    outputs.background_color = [80, 80, 80]
+    outputs.sprites << tiles.map(&:sprite)
+    outputs.sprites << (player.rect.merge path: 'sprites/square/green.png')
+
+    mouse_overlay = {
+      x: (inputs.mouse.x.ifloor state.tile_size),
+      y: (inputs.mouse.y.ifloor state.tile_size),
+      w: state.tile_size,
+      h: state.tile_size,
+      a: 100
+    }
+
+    mouse_overlay = mouse_overlay.merge r: 255 if state.delete_mode
+
+    if state.mouse_held
+      outputs.primitives << mouse_overlay.border
+    else
+      outputs.primitives << mouse_overlay.solid
+    end
+  end
+
+  def input_edit_map
+    state.mouse_held = true  if inputs.mouse.down
+    state.mouse_held = false if inputs.mouse.up
+
+    if inputs.keyboard.x
+      state.delete_mode = true
+    elsif inputs.keyboard.key_up.x
+      state.delete_mode = false
+    end
+
+    return unless state.mouse_held
+
+    ordinal = { x: (inputs.mouse.x.idiv state.tile_size),
+                y: (inputs.mouse.y.idiv state.tile_size) }
+
+    found = find_tile ordinal
+    if !found && !state.delete_mode
+      tiles << (state.new_entity :tile, ordinal)
+      recompute_tiles
+    elsif found && state.delete_mode
+      tiles.delete found
+      recompute_tiles
+    end
+  end
+
+  def input_player
+    player.dx += inputs.left_right
+
+    if inputs.keyboard.key_down.space && inputs.keyboard.down
+      player.dy             = player.jump_power * -1
+      player.jumped_at      = 0
+      player.jumped_down_at = state.tick_count
+    elsif inputs.keyboard.key_down.space
+      player.dy             = player.jump_power
+      player.jumped_at      = state.tick_count
+      player.jumped_down_at = 0
+    end
+  end
+
+  def calc_player
+    calc_player_rect
+    calc_below
+    calc_left
+    calc_right
+    calc_above
+    calc_player_dy
+    calc_player_dx
+    reset_player if player_off_stage?
+  end
+
+  def calc_player_rect
+    player.rect      = current_player_rect
+    player.next_rect = player.rect.merge x: player.x + player.dx,
+                                         y: player.y + player.dy
+    player.prev_rect = player.rect.merge x: player.x - player.dx,
+                                         y: player.y - player.dy
+  end
+
+  def calc_below
+    return unless player.dy <= 0
+    tiles_below = find_tiles { |t| t.rect.top <= player.y }
+    collision = find_colliding_tile tiles_below, (player.rect.merge y: player.next_rect.y)
+    return unless collision
+    if collision.neighbors.b == :none && player.jumped_down_at.elapsed_time < 10
+      player.dy = -1
+    else
+      player.y  = collision.rect.y + state.tile_size
+      player.dy = 0
+    end
+  end
+
+  def calc_left
+    return unless player.dx < 0
+    tiles_left = find_tiles { |t| t.rect.right <= player.prev_rect.left }
+    collision = find_colliding_tile tiles_left, (player.rect.merge x: player.next_rect.x)
+    return unless collision
+    player.x  = collision.rect.right
+    player.dx = 0
+  end
+
+  def calc_right
+    return unless player.dx > 0
+    tiles_right = find_tiles { |t| t.rect.left >= player.prev_rect.right }
+    collision = find_colliding_tile tiles_right, (player.rect.merge x: player.next_rect.x)
+    return unless collision
+    player.x  = collision.rect.left - player.rect.w
+    player.dx = 0
+  end
+
+  def calc_above
+    return unless player.dy > 0
+    tiles_above = find_tiles { |t| t.rect.y >= player.y }
+    collision = find_colliding_tile tiles_above, (player.rect.merge y: player.next_rect.y)
+    return unless collision
+    return if collision.neighbors.t == :none
+    player.dy = 0
+    player.y  = collision.rect.bottom - player.rect.h
+  end
+
+  def calc_player_dx
+    player.y  += player.dy
+    player.dy += state.gravity
+    player.dy += player.dy * state.drag ** 2 * -1
+  end
+
+  def calc_player_dy
+    player.dx  = player.dx.clamp(-5,  5)
+    player.dx *= 0.9
+    player.x  += player.dx
+  end
+
+  def reset_player
+    player.x  = 100
+    player.y  = 720
+    player.dy = 0
+  end
+
+  def recompute_tiles
+    tiles.each do |t|
+      t.w = state.tile_size
+      t.h = state.tile_size
+      t.neighbors = tile_neighbors t, tiles
+
+      t.rect = [t.x * state.tile_size,
+                t.y * state.tile_size,
+                state.tile_size,
+                state.tile_size].rect.to_hash
+
+      sprite_sub_path = t.neighbors.mask.map { |m| flip_bit m }.join("")
+
+      t.sprite = {
+        x: t.x * state.tile_size,
+        y: t.y * state.tile_size,
+        w: state.tile_size,
+        h: state.tile_size,
+        path: "sprites/tile/wall-#{sprite_sub_path}.png"
+      }
+    end
+  end
+
+  def flip_bit bit
+    return 0 if bit == 1
+    return 1
+  end
+
+  def player
+    state.player
+  end
+
+  def player_off_stage?
+    player.rect.top < grid.bottom ||
+    player.rect.right < grid.left ||
+    player.rect.left > grid.right
+  end
+
+  def current_player_rect
+    { x: player.x, y: player.y, w: player.size, h: player.size }
+  end
+
+  def tiles
+    state.tiles
+  end
+
+  def find_tile ordinal
+    tiles.find { |t| t.x == ordinal.x && t.y == ordinal.y }
+  end
+
+  def find_tiles &block
+    tiles.find_all(&block)
+  end
+
+  def find_colliding_tile tiles, target
+    tiles.find { |t| t.rect.intersect_rect? target }
+  end
+
+  def tile_neighbors tile, other_points
+    t = find_tile x: tile.x + 0, y: tile.y + 1
+    r = find_tile x: tile.x + 1, y: tile.y + 0
+    b = find_tile x: tile.x + 0, y: tile.y - 1
+    l = find_tile x: tile.x - 1, y: tile.y + 0
+
+    tile_t, tile_r, tile_b, tile_l = 0
+
+    tile_t = 1 if t
+    tile_r = 1 if r
+    tile_b = 1 if b
+    tile_l = 1 if l
+
+    state.new_entity :neighbors, mask: [tile_t, tile_r, tile_b, tile_l],
+                                 t:    t ? :some : :none,
+                                 b:    b ? :some : :none,
+                                 l:    l ? :some : :none,
+                                 r:    r ? :some : :none
+  end
+end
+
+def tick args
+  $game ||= Game.new
+  $game.args = args
+  $game.tick
+end
+
+
+Physics And Collisions - Jump Physics - main.rb
+# ./samples/04_physics_and_collisions/07_jump_physics/app/main.rb
+=begin
+
+ Reminders:
+
+ - args.state.new_entity: Used when we want to create a new object, like a sprite or button.
+   For example, if we want to create a new button, we would declare it as a new entity and
+   then define its properties. (Remember, you can use state to define ANY property and it will
+   be retained across frames.)
+
+ - args.outputs.solids: An array. The values generate a solid.
+   The parameters for a solid are [X, Y, WIDTH, HEIGHT, RED, GREEN, BLUE]
+   For more information about solids, go to mygame/documentation/03-solids-and-borders.md.
+
+ - num1.greater(num2): Returns the greater value.
+
+ - Hashes: Collection of unique keys and their corresponding values. The value can be found
+   using their keys.
+
+ - ARRAY#inside_rect?: Returns true or false depending on if the point is inside the rect.
+
+=end
+
+# This sample app is a game that requires the user to jump from one platform to the next.
+# As the player successfully clears platforms, they become smaller and move faster.
+
+class VerticalPlatformer
+  attr_gtk
+
+  # declares vertical platformer as new entity
+  def s
+    state.vertical_platformer ||= state.new_entity(:vertical_platformer)
+    state.vertical_platformer
+  end
+
+  # creates a new platform using a hash
+  def new_platform hash
+    s.new_entity_strict(:platform, hash) # platform key
+  end
+
+  # calls methods needed for game to run properly
+  def tick
+    defaults
+    render
+    calc
+    input
+  end
+
+  # Sets default values
+  def defaults
+    s.platforms ||= [ # initializes platforms collection with two platforms using hashes
+      new_platform(x: 0, y: 0, w: 700, h: 32, dx: 1, speed: 0, rect: nil),
+      new_platform(x: 0, y: 300, w: 700, h: 32, dx: 1, speed: 0, rect: nil), # 300 pixels higher
+    ]
+
+    s.tick_count  = args.state.tick_count
+    s.gravity     = -0.3 # what goes up must come down because of gravity
+    s.player.platforms_cleared ||= 0 # counts how many platforms the player has successfully cleared
+    s.player.x  ||= 0           # sets player values
+    s.player.y  ||= 100
+    s.player.w  ||= 64
+    s.player.h  ||= 64
+    s.player.dy ||= 0           # change in position
+    s.player.dx ||= 0
+    s.player_jump_power           = 15
+    s.player_jump_power_duration  = 10
+    s.player_max_run_speed        = 5
+    s.player_speed_slowdown_rate  = 0.9
+    s.player_acceleration         = 1
+    s.camera ||= { y: -100 } # shows view on screen (as the player moves upward, the camera does too)
+  end
+
+  # Outputs objects onto the screen
+  def render
+    outputs.solids << s.platforms.map do |p| # outputs platforms onto screen
+      [p.x + 300, p.y - s.camera[:y], p.w, p.h] # add 300 to place platform in horizontal center
+      # don't forget, position of platform is denoted by bottom left hand corner
+    end
+
+    # outputs player using hash
+    outputs.solids << {
+      x: s.player.x + 300, # player positioned on top of platform
+      y: s.player.y - s.camera[:y],
+      w: s.player.w,
+      h: s.player.h,
+      r: 100,              # color saturation
+      g: 100,
+      b: 200
+    }
+  end
+
+  # Performs calculations
+  def calc
+    s.platforms.each do |p| # for each platform in the collection
+      p.rect = [p.x, p.y, p.w, p.h] # set the definition
+    end
+
+    # sets player point by adding half the player's width to the player's x
+    s.player.point = [s.player.x + s.player.w.half, s.player.y] # change + to - and see what happens!
+
+    # search the platforms collection to find if the player's point is inside the rect of a platform
+    collision = s.platforms.find { |p| s.player.point.inside_rect? p.rect }
+
+    # if collision occurred and player is moving down (or not moving vertically at all)
+    if collision && s.player.dy <= 0
+      s.player.y = collision.rect.y + collision.rect.h - 2 # player positioned on top of platform
+      s.player.dy = 0 if s.player.dy < 0 # player stops moving vertically
+      if !s.player.platform
+        s.player.dx = 0 # no horizontal movement
+      end
+      # changes horizontal position of player by multiplying collision change in x (dx) by speed and adding it to current x
+      s.player.x += collision.dx * collision.speed
+      s.player.platform = collision # player is on the platform that it collided with (or landed on)
+      if s.player.falling # if player is falling
+        s.player.dx = 0  # no horizontal movement
+      end
+      s.player.falling = false
+      s.player.jumped_at = nil
+    else
+      s.player.platform = nil # player is not on a platform
+      s.player.y  += s.player.dy # velocity is the change in position
+      s.player.dy += s.gravity # acceleration is the change in velocity; what goes up must come down
+    end
+
+    s.platforms.each do |p| # for each platform in the collection
+      p.x += p.dx * p.speed # x is incremented by product of dx and speed (causes platform to move horizontally)
+      # changes platform's x so it moves left and right across the screen (between -300 and 300 pixels)
+      if p.x < -300 # if platform goes too far left
+        p.dx *= -1 # dx is scaled down
+        p.x = -300 # as far left as possible within scope
+      elsif p.x > (1000 - p.w) # if platform's x is greater than 300
+        p.dx *= -1
+        p.x = (1000 - p.w) # set to 300 (as far right as possible within scope)
+      end
+    end
+
+    delta = (s.player.y - s.camera[:y] - 100) # used to position camera view
+
+    if delta > -200
+      s.camera[:y] += delta * 0.01 # allows player to see view as they move upwards
+      s.player.x  += s.player.dx # velocity is change in position; change in x increases by dx
+
+      # searches platform collection to find platforms located more than 300 pixels above the player
+      has_platforms = s.platforms.find { |p| p.y > (s.player.y + 300) }
+      if !has_platforms # if there are no platforms 300 pixels above the player
+        width = 700 - (700 * (0.1 * s.player.platforms_cleared)) # the next platform is smaller than previous
+        s.player.platforms_cleared += 1 # player successfully cleared another platform
+        last_platform = s.platforms[-1] # platform just cleared becomes last platform
+        # another platform is created 300 pixels above the last platform, and this
+        # new platform has a smaller width and moves faster than all previous platforms
+        s.platforms << new_platform(x: (700 - width) * rand, # random x position
+                                    y: last_platform.y + 300,
+                                    w: width,
+                                    h: 32,
+                                    dx: 1.randomize(:sign), # random change in x
+                                    speed: 2 * s.player.platforms_cleared,
+                                    rect: nil)
+      end
+    else
+      s.as_hash.clear # otherwise clear the hash (no new platform is necessary)
+    end
+  end
+
+  # Takes input from the user to move the player
+  def input
+    if inputs.keyboard.space # if the space bar is pressed
+      s.player.jumped_at ||= s.tick_count # set to current frame
+
+      # if the time that has passed since the jump is less than the duration of a jump (10 frames)
+      # and the player is not falling
+      if s.player.jumped_at.elapsed_time < s.player_jump_power_duration && !s.player.falling
+        s.player.dy = s.player_jump_power # player jumps up
+      end
+    end
+
+    if inputs.keyboard.key_up.space # if space bar is in "up" state
+      s.player.falling = true # player is falling
+    end
+
+    if inputs.keyboard.left # if left key is pressed
+      s.player.dx -= s.player_acceleration # player's position changes, decremented by acceleration
+      s.player.dx = s.player.dx.greater(-s.player_max_run_speed) # dx is either current dx or -5, whichever is greater
+    elsif inputs.keyboard.right # if right key is pressed
+      s.player.dx += s.player_acceleration # player's position changes, incremented by acceleration
+      s.player.dx  = s.player.dx.lesser(s.player_max_run_speed) # dx is either current dx or 5, whichever is lesser
+    else
+      s.player.dx *= s.player_speed_slowdown_rate # scales dx down
+    end
+  end
+end
+
+$game = VerticalPlatformer.new
+
+def tick args
+  $game.args = args
+  $game.tick
+end
+
+
+Physics And Collisions - Bouncing On Collision - ball.rb
+# ./samples/04_physics_and_collisions/08_bouncing_on_collision/app/ball.rb
+GRAVITY = -0.08
+
+class Ball
+    attr_accessor :velocity, :center, :radius, :collision_enabled
+
+    def initialize args
+        #Start the ball in the top center
+        #@x = args.grid.w / 2
+        #@y = args.grid.h - 20
+
+        @velocity = {x: 0, y: 0}
+        #@width =  20
+        #@height = @width
+        @radius = 20.0 / 2.0
+        @center = {x: (args.grid.w / 2), y: (args.grid.h)}
+
+        #@left_wall = (args.state.board_width + args.grid.w / 8)
+        #@right_wall = @left_wall + args.state.board_width
+        @left_wall = 0
+        @right_wall = $args.grid.right
+
+        @max_velocity = 7
+        @collision_enabled = true
+    end
+
+    #Move the ball according to its velocity
+    def update args
+      @center.x += @velocity.x
+      @center.y += @velocity.y
+      @velocity.y += GRAVITY
+
+      alpha = 0.2
+      if @center.y-@radius <= 0
+        @velocity.y  = (@velocity.y.abs*0.7).abs
+        @velocity.x  = (@velocity.x.abs*0.9).abs * ((@velocity.x < 0) ? -1 : 1)
+
+        if @velocity.y.abs() < alpha
+          @velocity.y=0
+        end
+        if @velocity.x.abs() < alpha
+          @velocity.x=0
+        end
+      end
+
+      if @center.x > args.grid.right+@radius*2
+        @center.x = 0-@radius
+      elsif @center.x< 0-@radius*2
+        @center.x = args.grid.right + @radius
+      end
+    end
+
+    def wallBounds args
+        #if @x < @left_wall || @x + @width > @right_wall
+            #@velocity.x *= -1.1
+            #if @velocity.x > @max_velocity
+                #@velocity.x = @max_velocity
+            #elsif @velocity.x < @max_velocity * -1
+                #@velocity.x = @max_velocity * -1
+            #end
+        #end
+        #if @y < 0 || @y + @height > args.grid.h
+            #@velocity.y *= -1.1
+            #if @velocity.y > @max_velocity
+                #@velocity.y = @max_velocity
+            #elsif @velocity.y < @max_velocity * -1
+                #@velocity.y = @max_velocity * -1
+            #end
+        #end
+    end
+
+    #render the ball to the screen
+    def draw args
+        #args.outputs.solids << [@x, @y, @width, @height, 255, 255, 0];
+        args.outputs.sprites << [
+          @center.x-@radius,
+          @center.y-@radius,
+          @radius*2,
+          @radius*2,
+          "sprites/circle-white.png",
+          0,
+          255,
+          255,    #r
+          0,    #g
+          255   #b
+        ]
+    end
+  end
+
+
+Physics And Collisions - Bouncing On Collision - block.rb
+# ./samples/04_physics_and_collisions/08_bouncing_on_collision/app/block.rb
+DEGREES_TO_RADIANS = Math::PI / 180
+
+class Block
+  def initialize(x, y, block_size, rotation)
+    @x = x
+    @y = y
+    @block_size = block_size
+    @rotation = rotation
+
+    #The repel velocity?
+    @velocity = {x: 2, y: 0}
+
+    horizontal_offset = (3 * block_size) * Math.cos(rotation * DEGREES_TO_RADIANS)
+    vertical_offset = block_size * Math.sin(rotation * DEGREES_TO_RADIANS)
+
+    if rotation >= 0
+      theta = 90 - rotation
+      #The line doesn't visually line up exactly with the edge of the sprite, so artificially move it a bit
+      modifier = 5
+      x_offset = modifier * Math.cos(theta * DEGREES_TO_RADIANS)
+      y_offset = modifier * Math.sin(theta * DEGREES_TO_RADIANS)
+      @x1 = @x - x_offset
+      @y1 = @y + y_offset
+      @x2 = @x1 + horizontal_offset
+      @y2 = @y1 + (vertical_offset * 3)
+
+      @imaginary_line = [ @x1, @y1, @x2, @y2 ]
+    else
+      theta = 90 + rotation
+      x_offset = @block_size * Math.cos(theta * DEGREES_TO_RADIANS)
+      y_offset = @block_size * Math.sin(theta * DEGREES_TO_RADIANS)
+      @x1 = @x + x_offset
+      @y1 = @y + y_offset + 19
+      @x2 = @x1 + horizontal_offset
+      @y2 = @y1 + (vertical_offset * 3)
+
+      @imaginary_line = [ @x1, @y1, @x2, @y2 ]
+    end
+
+  end
+
+  def draw args
+    args.outputs.sprites << [
+      @x,
+      @y,
+      @block_size*3,
+      @block_size,
+      "sprites/square-green.png",
+      @rotation
+    ]
+
+    args.outputs.lines << @imaginary_line
+    args.outputs.solids << @debug_shape
+  end
+
+  def multiply_matricies
+  end
+
+  def calc args
+    if collision? args
+        collide args
+    end
+  end
+
+  #Determine if the ball and block are touching
+  def collision? args
+    #The minimum area enclosed by the center of the ball and the 2 corners of the block
+    #If the area ever drops below this value, we know there is a collision
+    min_area = ((@block_size * 3) * args.state.ball.radius) / 2
+
+    #https://www.mathopenref.com/coordtrianglearea.html
+    ax = @x1
+    ay = @y1
+    bx = @x2
+    by = @y2
+    cx = args.state.ball.center.x
+    cy = args.state.ball.center.y
+
+    current_area = (ax*(by-cy)+bx*(cy-ay)+cx*(ay-by))/2
+
+    collision = false
+    if @rotation >= 0
+      if (current_area < min_area &&
+        current_area > 0 &&
+        args.state.ball.center.y > @y1 &&
+        args.state.ball.center.x < @x2)
+
+        collision = true
+      end
+    else
+      if (current_area < min_area &&
+        current_area > 0 &&
+        args.state.ball.center.y > @y2 &&
+        args.state.ball.center.x > @x1)
+
+      collision = true
+      end
+    end
+
+    return collision
+  end
+
+  def collide args
+    #Slope of the block
+    slope = (@y2 - @y1) / (@x2 - @x1)
+
+    #Create a unit vector and tilt it (@rotation) number of degrees
+    x = -Math.cos(@rotation * DEGREES_TO_RADIANS)
+    y = Math.sin(@rotation * DEGREES_TO_RADIANS)
+
+    #Find the vector that is perpendicular to the slope
+    perpVect = { x: x, y: y }
+    mag  = (perpVect.x**2 + perpVect.y**2)**0.5                                 # find the magniude of the perpVect
+    perpVect = {x: perpVect.x/(mag), y: perpVect.y/(mag)}                       # divide the perpVect by the magniude to make it a unit vector
+
+    previousPosition = {                                                        # calculate an ESTIMATE of the previousPosition of the ball
+      x:args.state.ball.center.x-args.state.ball.velocity.x,
+      y:args.state.ball.center.y-args.state.ball.velocity.y
+    }
+
+    velocityMag = (args.state.ball.velocity.x**2 + args.state.ball.velocity.y**2)**0.5 # the current velocity magnitude of the ball
+    theta_ball = Math.atan2(args.state.ball.velocity.y, args.state.ball.velocity.x)         #the angle of the ball's velocity
+    theta_repel = (180 * DEGREES_TO_RADIANS) - theta_ball + (@rotation * DEGREES_TO_RADIANS)
+
+    fbx = velocityMag * Math.cos(theta_ball)                                    #the x component of the ball's velocity
+    fby = velocityMag * Math.sin(theta_ball)                                    #the y component of the ball's velocity
+
+    frx = velocityMag * Math.cos(theta_repel)                                       #the x component of the repel's velocity | magnitude is set to twice of fbx
+    fry = velocityMag * Math.sin(theta_repel)                                       #the y component of the repel's velocity | magnitude is set to twice of fby
+
+    args.state.display_value = velocityMag
+    fsumx = fbx+frx                                                             #sum of x forces
+    fsumy = fby+fry                                                             #sum of y forces
+    fr = velocityMag                                                            #fr is the resulting magnitude
+    thetaNew = Math.atan2(fsumy, fsumx)                                         #thetaNew is the resulting angle
+
+    xnew = fr*Math.cos(thetaNew)                                                #resulting x velocity
+    ynew = fr*Math.sin(thetaNew)                                                #resulting y velocity
+
+    dampener = 0.3
+    ynew *= dampener * 0.5
+
+    #If the bounce is very low, that means the ball is rolling and we don't want to dampenen the X velocity
+    if ynew > -0.1
+      xnew *= dampener
+    end
+
+    #Add the sine component of gravity back in (X component)
+    gravity_x = 4 * Math.sin(@rotation * DEGREES_TO_RADIANS)
+    xnew += gravity_x
+
+    args.state.ball.velocity.x = -xnew
+    args.state.ball.velocity.y = -ynew
+
+    #Set the position of the ball to the previous position so it doesn't warp throught the block
+    args.state.ball.center.x = previousPosition.x
+    args.state.ball.center.y = previousPosition.y
+  end
+end
+
+
+Physics And Collisions - Bouncing On Collision - cannon.rb
+# ./samples/04_physics_and_collisions/08_bouncing_on_collision/app/cannon.rb
+class Cannon
+  def initialize args
+    @pointA = {x: args.grid.right/2,y: args.grid.top}
+    @pointB = {x: args.inputs.mouse.x, y: args.inputs.mouse.y}
+  end
+  def update args
+    activeBall = args.state.ball
+    @pointB = {x: args.inputs.mouse.x, y: args.inputs.mouse.y}
+
+    if args.inputs.mouse.click
+      alpha = 0.01
+      activeBall.velocity.y = (@pointB.y - @pointA.y) * alpha
+      activeBall.velocity.x = (@pointB.x - @pointA.x) * alpha
+      activeBall.center = {x: (args.grid.w / 2), y: (args.grid.h)}
+    end
+  end
+  def render args
+    args.outputs.lines << [@pointA.x, @pointA.y, @pointB.x, @pointB.y]
+  end
+end
+
+
+Physics And Collisions - Bouncing On Collision - main.rb
+# ./samples/04_physics_and_collisions/08_bouncing_on_collision/app/main.rb
+INFINITY= 10**10
+
+require 'app/vector2d.rb'
+require 'app/peg.rb'
+require 'app/block.rb'
+require 'app/ball.rb'
+require 'app/cannon.rb'
+
+
+#Method to init default values
+def defaults args
+  args.state.pegs ||= []
+  args.state.blocks ||= []
+  args.state.cannon ||= Cannon.new args
+  args.state.ball ||= Ball.new args
+  args.state.horizontal_offset ||= 0
+  init_pegs args
+  init_blocks args
+
+  args.state.display_value ||= "test"
+end
+
+begin :default_methods
+  def init_pegs args
+    num_horizontal_pegs = 14
+    num_rows = 5
+
+    return unless args.state.pegs.count < num_rows * num_horizontal_pegs
+
+    block_size = 32
+    block_spacing = 50
+    total_width = num_horizontal_pegs * (block_size + block_spacing)
+    starting_offset = (args.grid.w - total_width) / 2 + block_size
+
+    for i in (0...num_rows)
+      for j in (0...num_horizontal_pegs)
+        row_offset = 0
+        if i % 2 == 0
+          row_offset = 20
+        else
+          row_offset = -20
+        end
+        args.state.pegs.append(Peg.new(j * (block_size+block_spacing) + starting_offset + row_offset, (args.grid.h - block_size * 2) - (i * block_size * 2)-90, block_size))
+      end
+    end
+
+  end
+
+  def init_blocks args
+    return unless args.state.blocks.count < 10
+
+    #Sprites are rotated in degrees, but the Ruby math functions work on radians
+    radians_to_degrees = Math::PI / 180
+
+    block_size = 25
+    #Rotation angle (in degrees) of the blocks
+    rotation = 30
+    vertical_offset = block_size * Math.sin(rotation * radians_to_degrees)
+    horizontal_offset = (3 * block_size) * Math.cos(rotation * radians_to_degrees)
+    center = args.grid.w / 2
+
+    for i in (0...5)
+      #Create a ramp of blocks. Not going to be perfect because of the float to integer conversion and anisotropic to isotropic coversion
+      args.state.blocks.append(Block.new((center + 100 + (i * horizontal_offset)).to_i, 100 + (vertical_offset * i) + (i * block_size), block_size, rotation))
+      args.state.blocks.append(Block.new((center - 100 - (i * horizontal_offset)).to_i, 100 + (vertical_offset * i) + (i * block_size), block_size, -rotation))
+    end
+  end
+end
+
+#Render loop
+def render args
+  args.outputs.borders << args.state.game_area
+  render_pegs args
+  render_blocks args
+  args.state.cannon.render args
+  args.state.ball.draw args
+end
+
+begin :render_methods
+  #Draw the pegs in a grid pattern
+  def render_pegs args
+    args.state.pegs.each do |peg|
+      peg.draw args
+    end
+  end
+
+  def render_blocks args
+    args.state.blocks.each do |block|
+      block.draw args
+    end
+  end
+
+end
+
+#Calls all methods necessary for performing calculations
+def calc args
+  args.state.pegs.each do |peg|
+    peg.calc args
+  end
+
+  args.state.blocks.each do |block|
+    block.calc args
+  end
+
+  args.state.ball.update args
+  args.state.cannon.update args
+end
+
+begin :calc_methods
+
+end
+
+def tick args
+  defaults args
+  render args
+  calc args
+end
+
+
+Physics And Collisions - Bouncing On Collision - peg.rb
+# ./samples/04_physics_and_collisions/08_bouncing_on_collision/app/peg.rb
+class Peg
+  def initialize(x, y, block_size)
+    @x = x                    # x cordinate of the LEFT side of the peg
+    @y = y                    # y cordinate of the RIGHT side of the peg
+    @block_size = block_size  # diameter of the peg
+
+    @radius = @block_size/2.0 # radius of the peg
+    @center = {               # cordinatees of the CENTER of the peg
+      x: @x+@block_size/2.0,
+      y: @y+@block_size/2.0
+    }
+
+    @r = 255 # color of the peg
+    @g = 0
+    @b = 0
+
+    @velocity = {x: 2, y: 0}
+  end
+
+  def draw args
+    args.outputs.sprites << [ # draw the peg according to the @x, @y, @radius, and the RGB
+      @x,
+      @y,
+      @radius*2.0,
+      @radius*2.0,
+      "sprites/circle-white.png",
+      0,
+      255,
+      @r,    #r
+      @g,    #g
+      @b   #b
+    ]
+  end
+
+
+  def calc args
+    if collisionWithBounce? args # if the is a collision with the bouncing ball
+      collide args
+      @r = 0
+      @b = 0
+      @g = 255
+    else
+    end
+  end
+
+
+  # do two circles (the ball and this peg) intersect
+  def collisionWithBounce? args
+    squareDistance = (  # the squared distance between the ball's center and this peg's center
+      (args.state.ball.center.x - @center.x) ** 2.0 +
+      (args.state.ball.center.y - @center.y) ** 2.0
+    )
+    radiusSum = (  # the sum of the radius squared of the this peg and the ball
+      (args.state.ball.radius + @radius) ** 2.0
+    )
+    # if the squareDistance is less or equal to radiusSum, then there is a radial intersection between the ball and this peg
+    return (squareDistance <= radiusSum)
+  end
+
+  # ! The following links explain the getRepelMagnitude function !
+  # https://raw.githubusercontent.com/DragonRuby/dragonruby-game-toolkit-physics/master/docs/docImages/LinearCollider_4.png
+  # https://raw.githubusercontent.com/DragonRuby/dragonruby-game-toolkit-physics/master/docs/docImages/LinearCollider_5.png
+  # https://github.com/DragonRuby/dragonruby-game-toolkit-physics/blob/master/docs/LinearCollider.md
+  def getRepelMagnitude (args, fbx, fby, vrx, vry, ballMag)
+    a = fbx ; b = vrx ; c = fby
+    d = vry ; e = ballMag
+    if b**2 + d**2 == 0
+      #unexpected
+    end
+
+    x1 = (-a*b+-c*d + (e**2 * b**2 - b**2 * c**2 + 2*a*b*c*d + e**2 + d**2 - a**2 * d**2)**0.5)/(b**2 + d**2)
+    x2 = -((a*b + c*d + (e**2 * b**2 - b**2 * c**2 + 2*a*b*c*d + e**2 * d**2 - a**2 * d**2)**0.5)/(b**2 + d**2))
+
+    err = 0.00001
+    o = ((fbx + x1*vrx)**2 + (fby + x1*vry)**2 ) ** 0.5
+    p = ((fbx + x2*vrx)**2 + (fby + x2*vry)**2 ) ** 0.5
+    r = 0
+
+    if (ballMag >= o-err and ballMag <= o+err)
+      r = x1
+    elsif (ballMag >= p-err and ballMag <= p+err)
+      r = x2
+    else
+      #unexpected
+    end
+
+    if (args.state.ball.center.x > @center.x)
+      return x2*-1
+    end
+
+    return x2
+
+    #return r
+  end
+
+  #this sets the new velocity of the ball once it has collided with this peg
+  def collide args
+    normalOfRCCollision = [                                                     #this is the normal of the collision in COMPONENT FORM
+      {x: @center.x, y: @center.y},                                             #see https://www.google.com/url?sa=i&url=https%3A%2F%2Fwww.mathscard.co.uk%2Fonline%2Fcircle-coordinate-geometry%2F&psig=AOvVaw2GcD-e2-nJR_IUKpw3hO98&ust=1605731315521000&source=images&cd=vfe&ved=0CAIQjRxqFwoTCMjBo7e1iu0CFQAAAAAdAAAAABAD
+      {x: args.state.ball.center.x, y: args.state.ball.center.y},
+    ]
+
+    normalSlope = (                                                             #normalSlope is the slope of normalOfRCCollision
+      (normalOfRCCollision[1].y - normalOfRCCollision[0].y) /
+      (normalOfRCCollision[1].x - normalOfRCCollision[0].x)
+    )
+    slope = normalSlope**-1.0 * -1                                              # slope is the slope of the tangent
+    # args.state.display_value = slope
+    pointA = {                                                                  # pointA and pointB are using the var slope to tangent in COMPONENT FORM
+      x: args.state.ball.center.x-1,
+      y: -(slope-args.state.ball.center.y)
+    }
+    pointB = {
+      x: args.state.ball.center.x+1,
+      y: slope+args.state.ball.center.y
+    }
+
+    perpVect = {x: pointB.x - pointA.x, y:pointB.y - pointA.y}                  # perpVect is to be VECTOR of the perpendicular tangent
+    mag  = (perpVect.x**2 + perpVect.y**2)**0.5                                 # find the magniude of the perpVect
+    perpVect = {x: perpVect.x/(mag), y: perpVect.y/(mag)}                       # divide the perpVect by the magniude to make it a unit vector
+    perpVect = {x: -perpVect.y, y: perpVect.x}                                  # swap the x and y and multiply by -1 to make the vector perpendicular
+    args.state.display_value = perpVect
+    if perpVect.y > 0                                                           #ensure perpVect points upward
+      perpVect = {x: perpVect.x*-1, y: perpVect.y*-1}
+    end
+
+    previousPosition = {                                                        # calculate an ESTIMATE of the previousPosition of the ball
+      x:args.state.ball.center.x-args.state.ball.velocity.x,
+      y:args.state.ball.center.y-args.state.ball.velocity.y
+    }
+
+    yInterc = pointA.y + -slope*pointA.x
+    if slope == INFINITY                                                        # the perpVect presently either points in the correct dirrection or it is 180 degrees off we need to correct this
+      if previousPosition.x < pointA.x
+        perpVect = {x: perpVect.x*-1, y: perpVect.y*-1}
+        yInterc = -INFINITY
+      end
+    elsif previousPosition.y < slope*previousPosition.x + yInterc               # check if ball is bellow or above the collider to determine if perpVect is - or +
+      perpVect = {x: perpVect.x*-1, y: perpVect.y*-1}
+    end
+
+    velocityMag =                                                               # the current velocity magnitude of the ball
+      (args.state.ball.velocity.x**2 + args.state.ball.velocity.y**2)**0.5
+    theta_ball=
+      Math.atan2(args.state.ball.velocity.y,args.state.ball.velocity.x)         #the angle of the ball's velocity
+    theta_repel=
+      Math.atan2(args.state.ball.center.y,args.state.ball.center.x)             #the angle of the repelling force(perpVect)
+
+    fbx = velocityMag * Math.cos(theta_ball)                                    #the x component of the ball's velocity
+    fby = velocityMag * Math.sin(theta_ball)                                    #the y component of the ball's velocity
+    repelMag = getRepelMagnitude(                                               # the magniude of the collision vector
+      args,
+      fbx,
+      fby,
+      perpVect.x,
+      perpVect.y,
+      (args.state.ball.velocity.x**2 + args.state.ball.velocity.y**2)**0.5
+    )
+    frx = repelMag* Math.cos(theta_repel)                                       #the x component of the repel's velocity | magnitude is set to twice of fbx
+    fry = repelMag* Math.sin(theta_repel)                                       #the y component of the repel's velocity | magnitude is set to twice of fby
+
+    fsumx = fbx+frx                            # sum of x forces
+    fsumy = fby+fry                            # sum of y forces
+    fr = velocityMag                           # fr is the resulting magnitude
+    thetaNew = Math.atan2(fsumy, fsumx)        # thetaNew is the resulting angle
+    xnew = fr*Math.cos(thetaNew)               # resulting x velocity
+    ynew = fr*Math.sin(thetaNew)               # resulting y velocity
+    if (args.state.ball.center.x >= @center.x) # this is necessary for the ball colliding on the right side of the peg
+      xnew=xnew.abs
+    end
+
+    args.state.ball.velocity.x = xnew                                           # set the x-velocity to the new velocity
+    if args.state.ball.center.y > @center.y                                     # if the ball is above the middle of the peg we need to temporarily ignore some of the gravity
+      args.state.ball.velocity.y = ynew + GRAVITY * 0.01
+    else
+      args.state.ball.velocity.y = ynew - GRAVITY * 0.01                        # if the ball is bellow the middle of the peg we need to temporarily increase the power of the gravity
+    end
+
+    args.state.ball.center.x+= args.state.ball.velocity.x                       # update the position of the ball so it never looks like the ball is intersecting the circle
+    args.state.ball.center.y+= args.state.ball.velocity.y
+  end
+end
+
+
+Physics And Collisions - Bouncing On Collision - vector2d.rb
+# ./samples/04_physics_and_collisions/08_bouncing_on_collision/app/vector2d.rb
+class Vector2d
+    attr_accessor :x, :y
+
+    def initialize x=0, y=0
+      @x=x
+      @y=y
+    end
+
+    #returns a vector multiplied by scalar x
+    #x [float] scalar
+    def mult x
+      r = Vector2d.new(0,0)
+      r.x=@x*x
+      r.y=@y*x
+      r
+    end
+
+    # vect [Vector2d] vector to copy
+    def copy vect
+      Vector2d.new(@x, @y)
+    end
+
+    #returns a new vector equivalent to this+vect
+    #vect [Vector2d] vector to add to self
+    def add vect
+      Vector2d.new(@x+vect.x,@y+vect.y)
+    end
+
+    #returns a new vector equivalent to this-vect
+    #vect [Vector2d] vector to subtract to self
+    def sub vect
+      Vector2d.new(@x-vect.c, @y-vect.y)
+    end
+
+    #return the magnitude of the vector
+    def mag
+      ((@x**2)+(@y**2))**0.5
+    end
+
+    #returns a new normalize version of the vector
+    def normalize
+      Vector2d.new(@x/mag, @y/mag)
+    end
+
+    #TODO delet?
+    def distABS vect
+      (((vect.x-@x)**2+(vect.y-@y)**2)**0.5).abs()
+    end
+  end
+
+Physics And Collisions - Arbitrary Collision - ball.rb
+# ./samples/04_physics_and_collisions/09_arbitrary_collision/app/ball.rb
+
+class Ball
+    attr_accessor :velocity, :child, :parent, :number, :leastChain
+    attr_reader :x, :y, :hypotenuse, :width, :height
+
+    def initialize args, number, leastChain, parent, child
+        #Start the ball in the top center
+        @number = number
+        @leastChain = leastChain
+        @x = args.grid.w / 2
+        @y = args.grid.h - 20
+
+        @velocity = Vector2d.new(2, -2)
+        @width =  10
+        @height = 10
+
+        @left_wall = (args.state.board_width + args.grid.w / 8)
+        @right_wall = @left_wall + args.state.board_width
+
+        @max_velocity = MAX_VELOCITY
+
+        @child = child
+        @parent = parent
+
+        @past = [{x: @x, y: @y}]
+        @next = nil
+    end
+
+    def reassignLeastChain (lc=nil)
+      if (lc == nil)
+        lc = @number
+      end
+      @leastChain = lc
+      if (parent != nil)
+        @parent.reassignLeastChain(lc)
+      end
+
+    end
+
+    def makeLeader args
+      if isLeader
+        return
+      end
+      @parent.reassignLeastChain
+      args.state.ballParents.push(self)
+      @parent = nil
+
+    end
+
+    def isLeader
+      return (parent == nil)
+    end
+
+    def receiveNext (p)
+      #trace!
+      if parent != nil
+        @x = p[:x]
+        @y = p[:y]
+        @velocity = p[:velocity]
+        #puts @x.to_s + "|" + @y.to_s + "|"+@velocity.to_s
+        @past.append(p)
+        if (@past.length >= BALL_DISTANCE)
+          if (@child != nil)
+            @child.receiveNext(@past[0])
+            @past.shift
+          end
+        end
+      end
+    end
+
+    #Move the ball according to its velocity
+    def update args
+
+        if isLeader
+          wallBounds args
+          @x += @velocity.x
+          @y += @velocity.y
+          @past.append({x: @x, y: @y, velocity: @velocity})
+          #puts @past
+
+          if (@past.length >= BALL_DISTANCE)
+            if (@child != nil)
+              @child.receiveNext(@past[0])
+              @past.shift
+            end
+          end
+
+        else
+          puts "unexpected"
+          raise "unexpected"
+        end
+    end
+
+    def wallBounds args
+        b= false
+        if @x < @left_wall
+          @velocity.x = @velocity.x.abs() * 1
+          b=true
+        elsif @x + @width > @right_wall
+          @velocity.x = @velocity.x.abs() * -1
+          b=true
+        end
+        if @y < 0
+          @velocity.y = @velocity.y.abs() * 1
+          b=true
+        elsif @y + @height > args.grid.h
+          @velocity.y = @velocity.y.abs() * -1
+          b=true
+        end
+        mag = (@velocity.x**2.0 + @velocity.y**2.0)**0.5
+        if (b == true && mag < MAX_VELOCITY)
+          @velocity.x*=1.1;
+          @velocity.y*=1.1;
+        end
+
+    end
+
+    #render the ball to the screen
+    def draw args
+
+        #update args
+        #args.outputs.solids << [@x, @y, @width, @height, 255, 255, 0];
+        #args.outputs.sprits << {
+          #x: @x,
+          #y: @y,
+          #w: @width,
+          #h: @height,
+          #path: "sprites/ball10.png"
+        #}
+        #args.outputs.sprites <<[@x, @y, @width, @height, "sprites/ball10.png"]
+        args.outputs.sprites << {x: @x, y: @y, w: @width, h: @height, path:"sprites/ball10.png" }
+    end
+
+    def getDraw args
+      #wallBounds args
+      #update args
+      #args.outputs.labels << [@x, @y, @number.to_s + "|" + @leastChain.to_s]
+      return [@x, @y, @width, @height, "sprites/ball10.png"]
+    end
+
+    def getPoints args
+      points = [
+        {x:@x+@width/2, y: @y},
+        {x:@x+@width, y:@y+@height/2},
+        {x:@x+@width/2,y:@y+@height},
+        {x:@x,y:@y+@height/2}
+      ]
+      #psize = 5.0
+      #for p in points
+        #args.outputs.solids << [p.x-psize/2.0, p.y-psize/2.0, psize, psize, 0, 0, 0];
+      #end
+      return points
+    end
+
+    def serialize
+      {x: @x, y:@y}
+    end
+
+    def inspect
+      serialize.to_s
+    end
+
+    def to_s
+      serialize.to_s
+    end
+  end
+
+
+Physics And Collisions - Arbitrary Collision - blocks.rb
+# ./samples/04_physics_and_collisions/09_arbitrary_collision/app/blocks.rb
+MAX_COUNT=100
+
+def universalUpdateOne args, shape
+  didHit = false
+  hitters = []
+  #puts shape.to_s
+  toCollide = nil
+  for b in args.state.balls
+    if [b.x, b.y, b.width, b.height].intersect_rect?(shape.bold)
+      didSquare = false
+      for s in shape.squareColliders
+        if (s.collision?(args, b))
+          didSquare = true
+          didHit = true
+          #s.collide(args, b)
+          toCollide = s
+          #hitter = b
+          hitters.append(b)
+        end #end if
+      end #end for
+      if (didSquare == false)
+        for c in shape.colliders
+          #puts args.state.ball.velocity
+          if c.collision?(args, b.getPoints(args),b)
+            #c.collide args, b
+            toCollide = c
+            didHit = true
+            hitters.append(b)
+          end #end if
+        end #end for
+      end #end if
+    end#end if
+  end#end for
+  if (didHit)
+    shape.count=0
+    hitters = hitters.uniq
+    for hitter in hitters
+      hitter.makeLeader args
+      #toCollide.collide(args, hitter)
+      if shape.home == "squares"
+        args.state.squares.delete(shape)
+      elsif shape.home == "tshapes"
+        args.state.tshapes.delete(shape)
+      else shape.home == "lines"
+        args.state.lines.delete(shape)
+      end
+    end
+
+    #puts "HIT!" + hitter.number
+  end
+end
+
+def universalUpdate args, shape
+  #puts shape.home
+  if (shape.count <= 1)
+    universalUpdateOne args, shape
+    return
+  end
+
+  didHit = false
+  hitter = nil
+  for b in args.state.ballParents
+    if [b.x, b.y, b.width, b.height].intersect_rect?(shape.bold)
+      didSquare = false
+      for s in shape.squareColliders
+        if (s.collision?(args, b))
+          didSquare = true
+          didHit = true
+          s.collide(args, b)
+          hitter = b
+        end
+      end
+      if (didSquare == false)
+        for c in shape.colliders
+          #puts args.state.ball.velocity
+          if c.collision?(args, b.getPoints(args),b)
+            c.collide args, b
+            didHit = true
+            hitter = b
+          end
+        end
+      end
+    end
+  end
+  if (didHit)
+    shape.count=shape.count-1
+    shape.damageCount.append([(hitter.leastChain+1 - hitter.number)-1, args.state.tick_count])
+
+  end
+  i=0
+  while i < shape.damageCount.length
+    if shape.damageCount[i][0] <= 0
+      shape.damageCount.delete_at(i)
+      i-=1
+    elsif shape.damageCount[i][1].elapsed_time > BALL_DISTANCE and shape.damageCount[i][0] > 1
+      shape.count-=1
+      shape.damageCount[i][0]-=1
+      shape.damageCount[i][1] = args.state.tick_count
+    end
+    i+=1
+  end
+end
 
-$gtk.reset
-$gtk.scheduled_callbacks.clear
-$gtk.schedule_callback 10 do
-  $gtk.console.set_command 'puts "Hello DragonRuby!"'
+
+class Square
+   attr_accessor :count, :x, :y, :home, :bold, :squareColliders, :colliders, :damageCount
+   def initialize(args, x, y, block_size, orientation, block_offset)
+        @x = x * block_size
+        @y = y * block_size
+        @block_size = block_size
+        @block_offset = block_offset
+        @orientation = orientation
+        @damageCount = []
+        @home = 'squares'
+
+
+        Kernel.srand()
+        @r = rand(255)
+        @g = rand(255)
+        @b = rand(255)
+
+        @count = rand(MAX_COUNT)+1
+
+        x_offset = (args.state.board_width + args.grid.w / 8) + @block_offset / 2
+        @x_adjusted = @x + x_offset
+        @y_adjusted = @y
+        @size_adjusted = @block_size * 2 - @block_offset
+
+        hypotenuse=args.state.ball_hypotenuse
+        @bold = [(@x_adjusted-hypotenuse/2)-1, (@y_adjusted-hypotenuse/2)-1, @size_adjusted + hypotenuse + 2, @size_adjusted + hypotenuse + 2]
+
+        @points = [
+          {x:@x_adjusted, y:@y_adjusted},
+          {x:@x_adjusted+@size_adjusted, y:@y_adjusted},
+          {x:@x_adjusted+@size_adjusted, y:@y_adjusted+@size_adjusted},
+          {x:@x_adjusted, y:@y_adjusted+@size_adjusted}
+        ]
+        @squareColliders = [
+          SquareCollider.new(@points[0].x,@points[0].y,{x:-1,y:-1}),
+          SquareCollider.new(@points[1].x-COLLISIONWIDTH,@points[1].y,{x:1,y:-1}),
+          SquareCollider.new(@points[2].x-COLLISIONWIDTH,@points[2].y-COLLISIONWIDTH,{x:1,y:1}),
+          SquareCollider.new(@points[3].x,@points[3].y-COLLISIONWIDTH,{x:-1,y:1}),
+        ]
+        @colliders = [
+          LinearCollider.new(@points[0],@points[1], :neg),
+          LinearCollider.new(@points[1],@points[2], :neg),
+          LinearCollider.new(@points[2],@points[3], :pos),
+          LinearCollider.new(@points[0],@points[3], :pos)
+        ]
+   end
+
+   def draw(args)
+    #Offset the coordinates to the edge of the game area
+    x_offset = (args.state.board_width + args.grid.w / 8) + @block_offset / 2
+    #args.outputs.solids << [@x + x_offset, @y, @block_size * 2 - @block_offset, @block_size * 2 - @block_offset, @r, @g, @b]
+    args.outputs.solids <<{x: (@x + x_offset), y: (@y), w: (@block_size * 2 - @block_offset), h: (@block_size * 2 - @block_offset), r: @r , g: @g , b: @b }
+    #args.outputs.solids << @bold.append([255,0,0])
+    args.outputs.labels << [@x + x_offset + (@block_size * 2 - @block_offset)/2, (@y) + (@block_size * 2 - @block_offset)/2, @count.to_s]
+
+   end
+
+   def update args
+     universalUpdate args, self
+   end
+end
+
+class TShape
+    attr_accessor :count, :x, :y, :home, :bold, :squareColliders, :colliders, :damageCount
+    def initialize(args, x, y, block_size, orientation, block_offset)
+        @x = x * block_size
+        @y = y * block_size
+        @block_size = block_size
+        @block_offset = block_offset
+        @orientation = orientation
+        @damageCount = []
+        @home = "tshapes"
+
+        Kernel.srand()
+        @r = rand(255)
+        @g = rand(255)
+        @b = rand(255)
+
+        @count = rand(MAX_COUNT)+1
+
+
+        @shapePoints = getShapePoints(args)
+        minX={x:INFINITY, y:0}
+        minY={x:0, y:INFINITY}
+        maxX={x:-INFINITY, y:0}
+        maxY={x:0, y:-INFINITY}
+        for p in @shapePoints
+          if p.x < minX.x
+            minX = p
+          end
+          if p.x > maxX.x
+            maxX = p
+          end
+          if p.y < minY.y
+            minY = p
+          end
+          if p.y > maxY.y
+            maxY = p
+          end
+        end
+
+
+        hypotenuse=args.state.ball_hypotenuse
+
+        @bold = [(minX.x-hypotenuse/2)-1, (minY.y-hypotenuse/2)-1, -((minX.x-hypotenuse/2)-1)+(maxX.x + hypotenuse + 2), -((minY.y-hypotenuse/2)-1)+(maxY.y + hypotenuse + 2)]
+    end
+    def getShapePoints(args)
+      points=[]
+      x_offset = (args.state.board_width + args.grid.w / 8) + (@block_offset / 2)
+
+      if @orientation == :right
+          #args.outputs.solids << [@x + x_offset, @y, @block_size - @block_offset, @block_size * 3 - @block_offset, @r, @g, @b]
+          #args.outputs.solids << [@x + x_offset, @y + @block_size, @block_size * 2, @block_size, @r, @g, @b]
+          points = [
+            {x:@x + x_offset, y:@y},
+            {x:(@x + x_offset)+(@block_size - @block_offset), y:@y},
+            {x:(@x + x_offset)+(@block_size - @block_offset),y:@y + @block_size},
+            {x:(@x + x_offset)+ @block_size * 2,y:@y + @block_size},
+            {x:(@x + x_offset)+ @block_size * 2,y:@y + @block_size+@block_size},
+            {x:(@x + x_offset)+(@block_size - @block_offset),y:@y + @block_size+@block_size},
+            {x:(@x + x_offset)+(@block_size - @block_offset), y:@y+ @block_size * 3 - @block_offset},
+            {x:@x + x_offset , y:@y+ @block_size * 3 - @block_offset}
+          ]
+          @squareColliders = [
+            SquareCollider.new(points[0].x,points[0].y,{x:-1,y:-1}),
+            SquareCollider.new(points[1].x-COLLISIONWIDTH,points[1].y,{x:1,y:-1}),
+            SquareCollider.new(points[2].x,points[2].y-COLLISIONWIDTH,{x:1,y:-1}),
+            SquareCollider.new(points[3].x-COLLISIONWIDTH,points[3].y,{x:1,y:-1}),
+            SquareCollider.new(points[4].x-COLLISIONWIDTH,points[4].y-COLLISIONWIDTH,{x:1,y:1}),
+            SquareCollider.new(points[5].x,points[5].y,{x:1,y:1}),
+            SquareCollider.new(points[6].x-COLLISIONWIDTH,points[6].y-COLLISIONWIDTH,{x:1,y:1}),
+            SquareCollider.new(points[7].x,points[7].y-COLLISIONWIDTH,{x:-1,y:1}),
+          ]
+          @colliders = [
+            LinearCollider.new(points[0],points[1], :neg),
+            LinearCollider.new(points[1],points[2], :neg),
+            LinearCollider.new(points[2],points[3], :neg),
+            LinearCollider.new(points[3],points[4], :neg),
+            LinearCollider.new(points[4],points[5], :pos),
+            LinearCollider.new(points[5],points[6], :neg),
+            LinearCollider.new(points[6],points[7], :pos),
+            LinearCollider.new(points[0],points[7], :pos)
+          ]
+      elsif @orientation == :up
+          #args.outputs.solids << [@x + x_offset, @y, @block_size * 3 - @block_offset, @block_size - @block_offset, @r, @g, @b]
+          #args.outputs.solids << [@x + x_offset + @block_size, @y, @block_size, @block_size * 2, @r, @g, @b]
+          points = [
+            {x:@x + x_offset, y:@y},
+            {x:(@x + x_offset)+(@block_size * 3 - @block_offset), y:@y},
+            {x:(@x + x_offset)+(@block_size * 3 - @block_offset), y:@y+(@block_size - @block_offset)},
+            {x:@x + x_offset + @block_size + @block_size, y:@y+(@block_size - @block_offset)},
+            {x:@x + x_offset + @block_size + @block_size, y:@y+@block_size*2},
+            {x:@x + x_offset + @block_size, y:@y+@block_size*2},
+            {x:@x + x_offset + @block_size, y:@y+(@block_size - @block_offset)},
+            {x:@x + x_offset, y:@y+(@block_size - @block_offset)}
+          ]
+          @squareColliders = [
+            SquareCollider.new(points[0].x,points[0].y,{x:-1,y:-1}),
+            SquareCollider.new(points[1].x-COLLISIONWIDTH,points[1].y,{x:1,y:-1}),
+            SquareCollider.new(points[2].x-COLLISIONWIDTH,points[2].y-COLLISIONWIDTH,{x:1,y:1}),
+            SquareCollider.new(points[3].x,points[3].y,{x:1,y:1}),
+            SquareCollider.new(points[4].x-COLLISIONWIDTH,points[4].y-COLLISIONWIDTH,{x:1,y:1}),
+            SquareCollider.new(points[5].x,points[5].y-COLLISIONWIDTH,{x:-1,y:1}),
+            SquareCollider.new(points[6].x-COLLISIONWIDTH,points[6].y,{x:-1,y:1}),
+            SquareCollider.new(points[7].x,points[7].y-COLLISIONWIDTH,{x:-1,y:1}),
+          ]
+          @colliders = [
+            LinearCollider.new(points[0],points[1], :neg),
+            LinearCollider.new(points[1],points[2], :neg),
+            LinearCollider.new(points[2],points[3], :pos),
+            LinearCollider.new(points[3],points[4], :neg),
+            LinearCollider.new(points[4],points[5], :pos),
+            LinearCollider.new(points[5],points[6], :neg),
+            LinearCollider.new(points[6],points[7], :pos),
+            LinearCollider.new(points[0],points[7], :pos)
+          ]
+      elsif @orientation == :left
+          #args.outputs.solids << [@x + x_offset + @block_size, @y, @block_size - @block_offset, @block_size * 3 - @block_offset, @r, @g, @b]
+          #args.outputs.solids << [@x + x_offset, @y + @block_size, @block_size * 2 - @block_offset, @block_size - @block_offset, @r, @g, @b]
+          xh = @x + x_offset
+          #points = [
+            #{x:@x + x_offset, y:@y},
+            #{x:(@x + x_offset)+(@block_size - @block_offset), y:@y},
+            #{x:(@x + x_offset)+(@block_size - @block_offset),y:@y + @block_size},
+            #{x:(@x + x_offset)+ @block_size * 2,y:@y + @block_size},
+            #{x:(@x + x_offset)+ @block_size * 2,y:@y + @block_size+@block_size},
+            #{x:(@x + x_offset)+(@block_size - @block_offset),y:@y + @block_size+@block_size},
+            #{x:(@x + x_offset)+(@block_size - @block_offset), y:@y+ @block_size * 3 - @block_offset},
+            #{x:@x + x_offset , y:@y+ @block_size * 3 - @block_offset}
+          #]
+          points = [
+            {x:@x + x_offset + @block_size, y:@y},
+            {x:@x + x_offset + @block_size + (@block_size - @block_offset), y:@y},
+            {x:@x + x_offset + @block_size + (@block_size - @block_offset),y:@y+@block_size*3- @block_offset},
+            {x:@x + x_offset + @block_size, y:@y+@block_size*3- @block_offset},
+            {x:@x + x_offset+@block_size, y:@y+@block_size*2- @block_offset},
+            {x:@x + x_offset, y:@y+@block_size*2- @block_offset},
+            {x:@x + x_offset, y:@y+@block_size},
+            {x:@x + x_offset+@block_size, y:@y+@block_size}
+          ]
+          @squareColliders = [
+            SquareCollider.new(points[0].x,points[0].y,{x:-1,y:-1}),
+            SquareCollider.new(points[1].x-COLLISIONWIDTH,points[1].y,{x:1,y:-1}),
+            SquareCollider.new(points[2].x-COLLISIONWIDTH,points[2].y-COLLISIONWIDTH,{x:1,y:1}),
+            SquareCollider.new(points[3].x,points[3].y-COLLISIONWIDTH,{x:-1,y:1}),
+            SquareCollider.new(points[4].x-COLLISIONWIDTH,points[4].y,{x:-1,y:1}),
+            SquareCollider.new(points[5].x,points[5].y-COLLISIONWIDTH,{x:-1,y:1}),
+            SquareCollider.new(points[6].x,points[6].y,{x:-1,y:-1}),
+            SquareCollider.new(points[7].x-COLLISIONWIDTH,points[7].y-COLLISIONWIDTH,{x:-1,y:-1}),
+          ]
+          @colliders = [
+            LinearCollider.new(points[0],points[1], :neg),
+            LinearCollider.new(points[1],points[2], :neg),
+            LinearCollider.new(points[2],points[3], :pos),
+            LinearCollider.new(points[3],points[4], :neg),
+            LinearCollider.new(points[4],points[5], :pos),
+            LinearCollider.new(points[5],points[6], :neg),
+            LinearCollider.new(points[6],points[7], :neg),
+            LinearCollider.new(points[0],points[7], :pos)
+          ]
+      elsif @orientation == :down
+          #args.outputs.solids << [@x + x_offset, @y + @block_size, @block_size * 3 - @block_offset, @block_size - @block_offset, @r, @g, @b]
+          #args.outputs.solids << [@x + x_offset + @block_size, @y, @block_size - @block_offset, @block_size * 2 - @block_offset, @r, @g, @b]
+
+          points = [
+            {x:@x + x_offset, y:@y+(@block_size*2)-@block_offset},
+            {x:@x + x_offset+ @block_size*3-@block_offset, y:@y+(@block_size*2)-@block_offset},
+            {x:@x + x_offset+ @block_size*3-@block_offset, y:@y+(@block_size)},
+            {x:@x + x_offset+ @block_size*2-@block_offset, y:@y+(@block_size)},
+            {x:@x + x_offset+ @block_size*2-@block_offset, y:@y},#
+            {x:@x + x_offset+ @block_size, y:@y},#
+            {x:@x + x_offset + @block_size, y:@y+(@block_size)},
+            {x:@x + x_offset, y:@y+(@block_size)}
+          ]
+          @squareColliders = [
+            SquareCollider.new(points[0].x,points[0].y-COLLISIONWIDTH,{x:-1,y:1}),
+            SquareCollider.new(points[1].x-COLLISIONWIDTH,points[1].y-COLLISIONWIDTH,{x:1,y:1}),
+            SquareCollider.new(points[2].x-COLLISIONWIDTH,points[2].y,{x:1,y:-1}),
+            SquareCollider.new(points[3].x,points[3].y-COLLISIONWIDTH,{x:1,y:-1}),
+            SquareCollider.new(points[4].x-COLLISIONWIDTH,points[4].y,{x:1,y:-1}),
+            SquareCollider.new(points[5].x,points[5].y,{x:-1,y:-1}),
+            SquareCollider.new(points[6].x-COLLISIONWIDTH,points[6].y-COLLISIONWIDTH,{x:-1,y:-1}),
+            SquareCollider.new(points[7].x,points[7].y,{x:-1,y:-1}),
+          ]
+          @colliders = [
+            LinearCollider.new(points[0],points[1], :pos),
+            LinearCollider.new(points[1],points[2], :pos),
+            LinearCollider.new(points[2],points[3], :neg),
+            LinearCollider.new(points[3],points[4], :pos),
+            LinearCollider.new(points[4],points[5], :neg),
+            LinearCollider.new(points[5],points[6], :pos),
+            LinearCollider.new(points[6],points[7], :neg),
+            LinearCollider.new(points[0],points[7], :neg)
+          ]
+      end
+      return points
+    end
+
+    def draw(args)
+        #Offset the coordinates to the edge of the game area
+        x_offset = (args.state.board_width + args.grid.w / 8) + (@block_offset / 2)
+
+        if @orientation == :right
+            #args.outputs.solids << [@x + x_offset, @y, @block_size - @block_offset, @block_size * 3 - @block_offset, @r, @g, @b]
+            args.outputs.solids << {x: (@x + x_offset), y: @y, w: @block_size - @block_offset, h: (@block_size * 3 - @block_offset), r: @r , g: @g, b: @b}
+            #args.outputs.solids << [@x + x_offset, @y + @block_size, @block_size * 2, @block_size, @r, @g, @b]
+            args.outputs.solids << {x: (@x + x_offset), y: (@y + @block_size), w: (@block_size * 2), h: (@block_size), r: @r , g: @g, b: @b }
+        elsif @orientation == :up
+            #args.outputs.solids << [@x + x_offset, @y, @block_size * 3 - @block_offset, @block_size - @block_offset, @r, @g, @b]
+            args.outputs.solids << {x: (@x + x_offset), y: (@y), w: (@block_size * 3 - @block_offset), h: (@block_size - @block_offset), r: @r , g: @g, b: @b}
+            #args.outputs.solids << [@x + x_offset + @block_size, @y, @block_size, @block_size * 2, @r, @g, @b]
+            args.outputs.solids << {x: (@x + x_offset + @block_size), y: (@y), w: (@block_size), h: (@block_size * 2), r: @r , g: @g, b: @b}
+        elsif @orientation == :left
+            #args.outputs.solids << [@x + x_offset + @block_size, @y, @block_size - @block_offset, @block_size * 3 - @block_offset, @r, @g, @b]
+            args.outputs.solids << {x: (@x + x_offset + @block_size), y: (@y), w: (@block_size - @block_offset), h: (@block_size * 3 - @block_offset), r: @r , g: @g, b: @b}
+            #args.outputs.solids << [@x + x_offset, @y + @block_size, @block_size * 2 - @block_offset, @block_size - @block_offset, @r, @g, @b]
+            args.outputs.solids << {x: (@x + x_offset), y: (@y + @block_size), w: (@block_size * 2 - @block_offset), h: (@block_size - @block_offset), r: @r , g: @g, b: @b}
+        elsif @orientation == :down
+            #args.outputs.solids << [@x + x_offset, @y + @block_size, @block_size * 3 - @block_offset, @block_size - @block_offset, @r, @g, @b]
+            args.outputs.solids << {x: (@x + x_offset), y: (@y + @block_size), w: (@block_size * 3 - @block_offset), h: (@block_size - @block_offset), r: @r , g: @g, b: @b}
+            #args.outputs.solids << [@x + x_offset + @block_size, @y, @block_size - @block_offset, @block_size * 2 - @block_offset, @r, @g, @b]
+            args.outputs.solids << {x: (@x + x_offset + @block_size), y: (@y), w: (@block_size - @block_offset), h: ( @block_size * 2 - @block_offset), r: @r , g: @g, b: @b}
+        end
+
+        #psize = 5.0
+        #for p in @shapePoints
+          #args.outputs.solids << [p.x-psize/2, p.y-psize/2, psize, psize, 0, 0, 0]
+        #end
+        args.outputs.labels << [@x + x_offset + (@block_size * 2 - @block_offset)/2, (@y) + (@block_size * 2 - @block_offset)/2, @count.to_s]
+
+    end
+
+    def updateOne_old args
+      didHit = false
+      hitter = nil
+      toCollide = nil
+      for b in args.state.balls
+        if [b.x, b.y, b.width, b.height].intersect_rect?(@bold)
+          didSquare = false
+          for s in @squareColliders
+            if (s.collision?(args, b))
+              didSquare = true
+              didHit = true
+              #s.collide(args, b)
+              toCollide = s
+              hitter = b
+              break
+            end
+          end
+          if (didSquare == false)
+            for c in @colliders
+              #puts args.state.ball.velocity
+              if c.collision?(args, b.getPoints(args),b)
+                #c.collide args, b
+                toCollide = c
+                didHit = true
+                hitter = b
+                break
+              end
+            end
+          end
+        end
+        if didHit
+          break
+        end
+      end
+      if (didHit)
+        @count=0
+        hitter.makeLeader args
+        #toCollide.collide(args, hitter)
+        args.state.tshapes.delete(self)
+        #puts "HIT!" + hitter.number
+      end
+    end
+
+    def update_old args
+      if (@count == 1)
+        updateOne args
+        return
+      end
+      didHit = false
+      hitter = nil
+      for b in args.state.ballParents
+        if [b.x, b.y, b.width, b.height].intersect_rect?(@bold)
+          didSquare = false
+          for s in @squareColliders
+            if (s.collision?(args, b))
+              didSquare = true
+              didHit=true
+              s.collide(args, b)
+              hitter = b
+            end
+          end
+          if (didSquare == false)
+            for c in @colliders
+              #puts args.state.ball.velocity
+              if c.collision?(args, b.getPoints(args), b)
+                c.collide args, b
+                didHit=true
+                hitter = b
+              end
+            end
+          end
+        end
+      end
+      if (didHit)
+        @count=@count-1
+        @damageCount.append([(hitter.leastChain+1 - hitter.number)-1, args.state.tick_count])
+
+        if (@count == 0)
+          args.state.tshapes.delete(self)
+          return
+        end
+      end
+      i=0
+
+      while i < @damageCount.length
+        if @damageCount[i][0] <= 0
+          @damageCount.delete_at(i)
+          i-=1
+        elsif @damageCount[i][1].elapsed_time > BALL_DISTANCE
+          @count-=1
+          @damageCount[i][0]-=1
+        end
+        if (@count == 0)
+          args.state.tshapes.delete(self)
+          return
+        end
+        i+=1
+      end
+    end #end update
+
+    def update args
+      universalUpdate args, self
+    end
+
+end
+
+class Line
+    attr_accessor :count, :x, :y, :home, :bold, :squareColliders, :colliders, :damageCount
+    def initialize(args, x, y, block_size, orientation, block_offset)
+        @x = x * block_size
+        @y = y * block_size
+        @block_size = block_size
+        @block_offset = block_offset
+        @orientation = orientation
+        @damageCount = []
+        @home = "lines"
+
+        Kernel.srand()
+        @r = rand(255)
+        @g = rand(255)
+        @b = rand(255)
+
+        @count = rand(MAX_COUNT)+1
+
+        @shapePoints = getShapePoints(args)
+        minX={x:INFINITY, y:0}
+        minY={x:0, y:INFINITY}
+        maxX={x:-INFINITY, y:0}
+        maxY={x:0, y:-INFINITY}
+        for p in @shapePoints
+          if p.x < minX.x
+            minX = p
+          end
+          if p.x > maxX.x
+            maxX = p
+          end
+          if p.y < minY.y
+            minY = p
+          end
+          if p.y > maxY.y
+            maxY = p
+          end
+        end
+
+
+        hypotenuse=args.state.ball_hypotenuse
+
+        @bold = [(minX.x-hypotenuse/2)-1, (minY.y-hypotenuse/2)-1, -((minX.x-hypotenuse/2)-1)+(maxX.x + hypotenuse + 2), -((minY.y-hypotenuse/2)-1)+(maxY.y + hypotenuse + 2)]
+    end
+
+    def getShapePoints(args)
+      points=[]
+      x_offset = (args.state.board_width + args.grid.w / 8) + (@block_offset / 2)
+
+      if @orientation == :right
+        #args.outputs.solids << [@x + x_offset, @y, @block_size * 3 - @block_offset, @block_size - @block_offset, @r, @g, @b]
+        xa =@x + x_offset
+        ya =@y
+        wa =@block_size * 3 - @block_offset
+        ha =(@block_size - @block_offset)
+      elsif @orientation == :up
+        #args.outputs.solids << [@x + x_offset, @y, @block_size - @block_offset, @block_size * 3 - @block_offset, @r, @g, @b]
+        xa =@x + x_offset
+        ya =@y
+        wa =@block_size - @block_offset
+        ha =@block_size * 3 - @block_offset
+
+      elsif @orientation == :left
+        #args.outputs.solids << [@x + x_offset, @y, @block_size * 3 - @block_offset, @block_size - @block_offset, @r, @g, @b]
+        xa =@x + x_offset
+        ya =@y
+        wa =@block_size * 3 - @block_offset
+        ha =@block_size - @block_offset
+      elsif @orientation == :down
+        #args.outputs.solids << [@x + x_offset, @y, @block_size - @block_offset, @block_size * 3 - @block_offset, @r, @g, @b]
+        xa =@x + x_offset
+        ya =@y
+        wa =@block_size - @block_offset
+        ha =@block_size * 3 - @block_offset
+      end
+      points = [
+        {x: xa, y:ya},
+        {x: xa + wa,y:ya},
+        {x: xa + wa,y:ya+ha},
+        {x: xa, y:ya+ha},
+      ]
+      @squareColliders = [
+        SquareCollider.new(points[0].x,points[0].y,{x:-1,y:-1}),
+        SquareCollider.new(points[1].x-COLLISIONWIDTH,points[1].y,{x:1,y:-1}),
+        SquareCollider.new(points[2].x-COLLISIONWIDTH,points[2].y-COLLISIONWIDTH,{x:1,y:1}),
+        SquareCollider.new(points[3].x,points[3].y-COLLISIONWIDTH,{x:-1,y:1}),
+      ]
+      @colliders = [
+        LinearCollider.new(points[0],points[1], :neg),
+        LinearCollider.new(points[1],points[2], :neg),
+        LinearCollider.new(points[2],points[3], :pos),
+        LinearCollider.new(points[0],points[3], :pos),
+      ]
+      return points
+    end
+
+    def update args
+      universalUpdate args, self
+    end
+
+    def draw(args)
+        x_offset = (args.state.board_width + args.grid.w / 8) + @block_offset / 2
+
+        if @orientation == :right
+            args.outputs.solids << [@x + x_offset, @y, @block_size * 3 - @block_offset, @block_size - @block_offset, @r, @g, @b]
+        elsif @orientation == :up
+            args.outputs.solids << [@x + x_offset, @y, @block_size - @block_offset, @block_size * 3 - @block_offset, @r, @g, @b]
+        elsif @orientation == :left
+            args.outputs.solids << [@x + x_offset, @y, @block_size * 3 - @block_offset, @block_size - @block_offset, @r, @g, @b]
+        elsif @orientation == :down
+            args.outputs.solids << [@x + x_offset, @y, @block_size - @block_offset, @block_size * 3 - @block_offset, @r, @g, @b]
+        end
+
+        args.outputs.labels << [@x + x_offset + (@block_size * 2 - @block_offset)/2, (@y) + (@block_size * 2 - @block_offset)/2, @count.to_s]
+
+    end
+end
+
+
+Physics And Collisions - Arbitrary Collision - linear_collider.rb
+# ./samples/04_physics_and_collisions/09_arbitrary_collision/app/linear_collider.rb
+
+COLLISIONWIDTH=8
+
+class LinearCollider
+  attr_reader :pointA, :pointB
+  def initialize (pointA, pointB, mode,collisionWidth=COLLISIONWIDTH)
+    @pointA = pointA
+    @pointB = pointB
+    @mode = mode
+    @collisionWidth = collisionWidth
+
+    if (@pointA.x > @pointB.x)
+      @pointA, @pointB = @pointB, @pointA
+    end
+
+    @linearCollider_collision_once = false
+  end
+
+  def collisionSlope args
+    if (@pointB.x-@pointA.x == 0)
+      return INFINITY
+    end
+    return (@pointB.y - @pointA.y) / (@pointB.x - @pointA.x)
+  end
+
+
+  def collision? (args, points, ball=nil)
+
+    slope = collisionSlope args
+    result = false
+
+    # calculate a vector with a magnitude of (1/2)collisionWidth and a direction perpendicular to the collision line
+    vect=nil;mag=nil;vect=nil;
+    if @mode == :both
+      vect = {x: @pointB.x - @pointA.x, y:@pointB.y - @pointA.y}
+      mag  = (vect.x**2 + vect.y**2)**0.5
+      vect = {y: -1*(vect.x/(mag))*@collisionWidth*0.5, x: (vect.y/(mag))*@collisionWidth*0.5}
+    else
+      vect = {x: @pointB.x - @pointA.x, y:@pointB.y - @pointA.y}
+      mag  = (vect.x**2 + vect.y**2)**0.5
+      vect = {y: -1*(vect.x/(mag))*@collisionWidth, x: (vect.y/(mag))*@collisionWidth}
+    end
+
+    rpointA=nil;rpointB=nil;rpointC=nil;rpointD=nil;
+    if @mode == :pos
+      rpointA = {x:@pointA.x + vect.x, y:@pointA.y + vect.y}
+      rpointB = {x:@pointB.x + vect.x, y:@pointB.y + vect.y}
+      rpointC = {x:@pointB.x, y:@pointB.y}
+      rpointD = {x:@pointA.x, y:@pointA.y}
+    elsif @mode == :neg
+      rpointA = {x:@pointA.x, y:@pointA.y}
+      rpointB = {x:@pointB.x, y:@pointB.y}
+      rpointC = {x:@pointB.x - vect.x, y:@pointB.y - vect.y}
+      rpointD = {x:@pointA.x - vect.x, y:@pointA.y - vect.y}
+    elsif @mode == :both
+      rpointA = {x:@pointA.x + vect.x, y:@pointA.y + vect.y}
+      rpointB = {x:@pointB.x + vect.x, y:@pointB.y + vect.y}
+      rpointC = {x:@pointB.x - vect.x, y:@pointB.y - vect.y}
+      rpointD = {x:@pointA.x - vect.x, y:@pointA.y - vect.y}
+    end
+    #four point rectangle
+
+
+
+    if ball != nil
+      xs = [rpointA.x,rpointB.x,rpointC.x,rpointD.x]
+      ys = [rpointA.y,rpointB.y,rpointC.y,rpointD.y]
+      correct = 1
+      rect1 = [ball.x, ball.y, ball.width, ball.height]
+      #$r1 = rect1
+      rect2 = [xs.min-correct,ys.min-correct,(xs.max-xs.min)+correct*2,(ys.max-ys.min)+correct*2]
+      #$r2 = rect2
+      if rect1.intersect_rect?(rect2) == false
+        return false
+      end
+    end
+
+
+    #area of a triangle
+    triArea = -> (a,b,c) { ((a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y))/2.0).abs }
+
+    #if at least on point is in the rectangle then collision? is true - otherwise false
+    for point in points
+      #Check whether a given point lies inside a rectangle or not:
+      #if the sum of the area of traingls, PAB, PBC, PCD, PAD equal the area of the rec, then an intersection has occured
+      areaRec =  triArea.call(rpointA, rpointB, rpointC)+triArea.call(rpointA, rpointC, rpointD)
+      areaSum = [
+        triArea.call(point, rpointA, rpointB),triArea.call(point, rpointB, rpointC),
+        triArea.call(point, rpointC, rpointD),triArea.call(point, rpointA, rpointD)
+      ].inject(0){|sum,x| sum + x }
+      e = 0.0001 #allow for minor error
+      if areaRec>= areaSum-e and areaRec<= areaSum+e
+        result = true
+        #return true
+        break
+      end
+    end
+
+    #args.outputs.lines << [@pointA.x, @pointA.y, @pointB.x, @pointB.y,     000, 000, 000]
+    #args.outputs.lines << [rpointA.x, rpointA.y, rpointB.x, rpointB.y,     255, 000, 000]
+    #args.outputs.lines << [rpointC.x, rpointC.y, rpointD.x, rpointD.y,     000, 000, 255]
+
+
+    #puts (rpointA.x.to_s + " " +  rpointA.y.to_s + " " + rpointB.x.to_s + " "+ rpointB.y.to_s)
+    return result
+  end #end collision?
+
+  def getRepelMagnitude (fbx, fby, vrx, vry, ballMag)
+    a = fbx ; b = vrx ; c = fby
+    d = vry ; e = ballMag
+    if b**2 + d**2 == 0
+      #unexpected
+    end
+    x1 = (-a*b+-c*d + (e**2 * b**2 - b**2 * c**2 + 2*a*b*c*d + e**2 + d**2 - a**2 * d**2)**0.5)/(b**2 + d**2)
+    x2 = -((a*b + c*d + (e**2 * b**2 - b**2 * c**2 + 2*a*b*c*d + e**2 * d**2 - a**2 * d**2)**0.5)/(b**2 + d**2))
+    err = 0.00001
+    o = ((fbx + x1*vrx)**2 + (fby + x1*vry)**2 ) ** 0.5
+    p = ((fbx + x2*vrx)**2 + (fby + x2*vry)**2 ) ** 0.5
+    r = 0
+    if (ballMag >= o-err and ballMag <= o+err)
+      r = x1
+    elsif (ballMag >= p-err and ballMag <= p+err)
+      r = x2
+    else
+      #unexpected
+    end
+    return r
+  end
+
+  def collide args, ball
+    slope = collisionSlope args
+
+    # perpVect: normal vector perpendicular to collision
+    perpVect = {x: @pointB.x - @pointA.x, y:@pointB.y - @pointA.y}
+    mag  = (perpVect.x**2 + perpVect.y**2)**0.5
+    perpVect = {x: perpVect.x/(mag), y: perpVect.y/(mag)}
+    perpVect = {x: -perpVect.y, y: perpVect.x}
+    if perpVect.y > 0 #ensure perpVect points upward
+      perpVect = {x: perpVect.x*-1, y: perpVect.y*-1}
+    end
+    previousPosition = {
+      x:ball.x-ball.velocity.x,
+      y:ball.y-ball.velocity.y
+    }
+    yInterc = @pointA.y + -slope*@pointA.x
+    if slope == INFINITY
+      if previousPosition.x < @pointA.x
+        perpVect = {x: perpVect.x*-1, y: perpVect.y*-1}
+        yInterc = -INFINITY
+      end
+    elsif previousPosition.y < slope*previousPosition.x + yInterc #check if ball is bellow or above the collider to determine if perpVect is - or +
+      perpVect = {x: perpVect.x*-1, y: perpVect.y*-1}
+    end
+
+    velocityMag = (ball.velocity.x**2 + ball.velocity.y**2)**0.5
+    theta_ball=Math.atan2(ball.velocity.y,ball.velocity.x) #the angle of the ball's velocity
+    theta_repel=Math.atan2(perpVect.y,perpVect.x) #the angle of the repelling force(perpVect)
+
+    fbx = velocityMag * Math.cos(theta_ball) #the x component of the ball's velocity
+    fby = velocityMag * Math.sin(theta_ball) #the y component of the ball's velocity
+
+    #the magnitude of the repelling force
+    repelMag = getRepelMagnitude(fbx, fby, perpVect.x, perpVect.y, (ball.velocity.x**2 + ball.velocity.y**2)**0.5)
+    frx = repelMag* Math.cos(theta_repel) #the x component of the repel's velocity | magnitude is set to twice of fbx
+    fry = repelMag* Math.sin(theta_repel) #the y component of the repel's velocity | magnitude is set to twice of fby
+
+    fsumx = fbx+frx #sum of x forces
+    fsumy = fby+fry #sum of y forces
+    fr = velocityMag#fr is the resulting magnitude
+    thetaNew = Math.atan2(fsumy, fsumx)  #thetaNew is the resulting angle
+    xnew = fr*Math.cos(thetaNew)#resulting x velocity
+    ynew = fr*Math.sin(thetaNew)#resulting y velocity
+    if (velocityMag < MAX_VELOCITY)
+      ball.velocity =  Vector2d.new(xnew*1.1, ynew*1.1)
+    else
+      ball.velocity =  Vector2d.new(xnew, ynew)
+    end
+
+  end
+end
+
+
+Physics And Collisions - Arbitrary Collision - main.rb
+# ./samples/04_physics_and_collisions/09_arbitrary_collision/app/main.rb
+INFINITY= 10**10
+MAX_VELOCITY = 8.0
+BALL_COUNT = 90
+BALL_DISTANCE = 20
+require 'app/vector2d.rb'
+require 'app/blocks.rb'
+require 'app/ball.rb'
+require 'app/rectangle.rb'
+require 'app/linear_collider.rb'
+require 'app/square_collider.rb'
+
+
+
+#Method to init default values
+def defaults args
+  args.state.board_width ||= args.grid.w / 4
+  args.state.board_height ||= args.grid.h
+  args.state.game_area ||= [(args.state.board_width + args.grid.w / 8), 0, args.state.board_width, args.grid.h]
+  args.state.balls ||= []
+  args.state.num_balls ||= 0
+  args.state.ball_created_at ||= args.state.tick_count
+  args.state.ball_hypotenuse = (10**2 + 10**2)**0.5
+  args.state.ballParents ||=nil
+
+  init_blocks args
+  init_balls args
+end
+
+begin :default_methods
+  def init_blocks args
+    block_size = args.state.board_width / 8
+    #Space inbetween each block
+    block_offset = 4
+
+    args.state.squares ||=[
+      Square.new(args, 2, 0, block_size, :right, block_offset),
+      Square.new(args, 5, 0, block_size, :right, block_offset),
+      Square.new(args, 6, 7, block_size, :right, block_offset)
+    ]
+
+
+    #Possible orientations are :right, :left, :up, :down
+
+
+    args.state.tshapes ||= [
+      TShape.new(args, 0, 6, block_size, :left, block_offset),
+      TShape.new(args, 3, 3, block_size, :down, block_offset),
+      TShape.new(args, 0, 3, block_size, :right, block_offset),
+      TShape.new(args, 0, 11, block_size, :up, block_offset)
+    ]
+
+    args.state.lines ||= [
+      Line.new(args,3, 8, block_size, :down, block_offset),
+      Line.new(args, 7, 3, block_size, :up, block_offset),
+      Line.new(args, 3, 7, block_size, :right, block_offset)
+    ]
+
+    #exit()
+  end
+
+  def init_balls args
+    return unless args.state.num_balls < BALL_COUNT
+
+
+    #only create a new ball every 10 ticks
+    return unless args.state.ball_created_at.elapsed_time > 10
+
+    if (args.state.num_balls == 0)
+      args.state.balls.append(Ball.new(args,args.state.num_balls,BALL_COUNT-1, nil, nil))
+      args.state.ballParents = [args.state.balls[0]]
+    else
+      args.state.balls.append(Ball.new(args,args.state.num_balls,BALL_COUNT-1, args.state.balls.last, nil) )
+      args.state.balls[-2].child = args.state.balls[-1]
+    end
+    args.state.ball_created_at = args.state.tick_count
+    args.state.num_balls += 1
+  end
+end
+
+#Render loop
+def render args
+  bgClr = {r:10, g:10, b:200}
+  bgClr = {r:255-30, g:255-30, b:255-30}
+
+  args.outputs.solids << [0, 0, $args.grid.right, $args.grid.top, bgClr[:r], bgClr[:g], bgClr[:b]];
+  args.outputs.borders << args.state.game_area
+
+  render_instructions args
+  render_shapes args
+
+  render_balls args
+
+  #args.state.rectangle.draw args
+
+  args.outputs.sprites << [$args.grid.right-(args.state.board_width + args.grid.w / 8), 0, $args.grid.right, $args.grid.top, "sprites/square-white-2.png", 0, 255, bgClr[:r], bgClr[:g], bgClr[:b]]
+  args.outputs.sprites << [0, 0, (args.state.board_width + args.grid.w / 8), $args.grid.top, "sprites/square-white-2.png", 0, 255, bgClr[:r], bgClr[:g], bgClr[:b]]
+
+end
+
+begin :render_methods
+  def render_instructions args
+    #gtk.current_framerate
+    args.outputs.labels << [20, $args.grid.top-20, "FPS: " + $gtk.current_framerate.to_s]
+    if (args.state.balls != nil && args.state.balls[0] != nil)
+        bx =  args.state.balls[0].velocity.x
+        by =  args.state.balls[0].velocity.y
+        bmg = (bx**2.0 + by**2.0)**0.5
+        args.outputs.labels << [20, $args.grid.top-20-20, "V: " + bmg.to_s ]
+    end
+
+
+  end
+
+  def render_shapes args
+    for s in args.state.squares
+      s.draw args
+    end
+
+    for l in args.state.lines
+      l.draw args
+    end
+
+    for t in args.state.tshapes
+      t.draw args
+    end
+
+
+  end
+
+  def render_balls args
+    #args.state.balls.each do |ball|
+      #ball.draw args
+    #end
+
+    args.outputs.sprites << args.state.balls.map do |ball|
+      ball.getDraw args
+    end
+  end
+end
+
+#Calls all methods necessary for performing calculations
+def calc args
+  for b in args.state.ballParents
+    b.update args
+  end
+
+  for s in args.state.squares
+    s.update args
+  end
+
+  for l in args.state.lines
+    l.update args
+  end
+
+  for t in args.state.tshapes
+    t.update args
+  end
+
+
+
+end
+
+begin :calc_methods
+
+end
+
+def tick args
+  defaults args
+  render args
+  calc args
+end
+
+
+Physics And Collisions - Arbitrary Collision - paddle.rb
+# ./samples/04_physics_and_collisions/09_arbitrary_collision/app/paddle.rb
+class Paddle
+  attr_accessor :enabled
+
+  def initialize ()
+    @x=WIDTH/2
+    @y=100
+    @width=100
+    @height=20
+    @speed=10
+
+    @xyCollision  = LinearCollider.new({x: @x,y: @y+@height+5}, {x: @x+@width, y: @y+@height+5})
+    @xyCollision2 = LinearCollider.new({x: @x,y: @y}, {x: @x+@width, y: @y}, :pos)
+    @xyCollision3 = LinearCollider.new({x: @x,y: @y}, {x: @x, y: @y+@height+5})
+    @xyCollision4 = LinearCollider.new({x: @x+@width,y: @y}, {x: @x+@width, y: @y+@height+5}, :pos)
+
+    @enabled = true
+  end
+
+  def update args
+    @xyCollision.resetPoints({x: @x,y: @y+@height+5}, {x: @x+@width, y: @y+@height+5})
+    @xyCollision2.resetPoints({x: @x,y: @y}, {x: @x+@width, y: @y})
+    @xyCollision3.resetPoints({x: @x,y: @y}, {x: @x, y: @y+@height+5})
+    @xyCollision4.resetPoints({x: @x+@width,y: @y}, {x: @x+@width, y: @y+@height+5})
+
+    @xyCollision.update  args
+    @xyCollision2.update args
+    @xyCollision3.update args
+    @xyCollision4.update args
+
+    args.inputs.keyboard.key_held.left  ||= false
+    args.inputs.keyboard.key_held.right  ||= false
+
+    if not (args.inputs.keyboard.key_held.left == args.inputs.keyboard.key_held.right)
+      if args.inputs.keyboard.key_held.left && @enabled
+        @x-=@speed
+      elsif args.inputs.keyboard.key_held.right && @enabled
+        @x+=@speed
+      end
+    end
+
+    xmin =WIDTH/4
+    xmax = 3*(WIDTH/4)
+    @x = (@x+@width > xmax) ? xmax-@width : (@x

+Physics And Collisions - Arbitrary Collision - rectangle.rb
+# ./samples/04_physics_and_collisions/09_arbitrary_collision/app/rectangle.rb
+class Rectangle
+  def initialize args
+
+    @image = "sprites/roundSquare_white.png"
+    @width  = 160.0
+    @height = 80.0
+    @x=$args.grid.right/2.0 - @width/2.0
+    @y=$args.grid.top/2.0 - @height/2.0
+
+    @xtmp = @width  * (1.0/10.0)
+    @ytmp = @height * (1.0/10.0)
+
+    #ball0 = args.state.balls[0]
+    #hypotenuse = (args.state.balls[0].width**2 + args.state.balls[0].height**2)**0.5
+    hypotenuse=args.state.ball_hypotenuse
+    @boldXY = {x:(@x-hypotenuse/2)-1, y:(@y-hypotenuse/2)-1}
+    @boldWidth = @width + hypotenuse + 2
+    @boldHeight = @height + hypotenuse + 2
+    @bold = [(@x-hypotenuse/2)-1,(@y-hypotenuse/2)-1,@width + hypotenuse + 2,@height + hypotenuse + 2]
+
+
+    @points = [
+      {x:@x,        y:@y+@ytmp},
+      {x:@x+@xtmp,        y:@y},
+      {x:@x+@width-@xtmp, y:@y},
+      {x:@x+@width, y:@y+@ytmp},
+      {x:@x+@width, y:@y+@height-@ytmp},#
+      {x:@x+@width-@xtmp, y:@y+@height},
+      {x:@x+@xtmp,        y:@y+@height},
+      {x:@x,        y:@y+@height-@ytmp}
+    ]
+
+    @colliders = []
+    #i = 0
+    #while i < @points.length-1
+      #@colliders.append(LinearCollider.new(@points[i],@points[i+1],:pos))
+      #i+=1
+    #end
+    @colliders.append(LinearCollider.new(@points[0],@points[1], :neg))
+    @colliders.append(LinearCollider.new(@points[1],@points[2], :neg))
+    @colliders.append(LinearCollider.new(@points[2],@points[3], :neg))
+    @colliders.append(LinearCollider.new(@points[3],@points[4], :neg))
+    @colliders.append(LinearCollider.new(@points[4],@points[5], :pos))
+    @colliders.append(LinearCollider.new(@points[5],@points[6], :pos))
+    @colliders.append(LinearCollider.new(@points[6],@points[7], :pos))
+    @colliders.append(LinearCollider.new(@points[0],@points[7], :pos))
+
+  end
+
+  def update args
+
+    for b in args.state.balls
+      if [b.x, b.y, b.width, b.height].intersect_rect?(@bold)
+        for c in @colliders
+          if c.collision?(args, b.getPoints(args),b)
+            c.collide args, b
+          end
+        end
+      end
+    end
+  end
+
+  def draw args
+    args.outputs.sprites << [
+      @x,                                       # X
+      @y,                                       # Y
+      @width,                                   # W
+      @height,                                  # H
+      @image,                                   # PATH
+      0,                                        # ANGLE
+      255,                                      # ALPHA
+      219,                                      # RED_SATURATION
+      112,                                      # GREEN_SATURATION
+      147                                       # BLUE_SATURATION
+    ]
+    #args.outputs.sprites << [@x, @y, @width, @height, "sprites/roundSquare_small_black.png"]
+  end
+
+  def serialize
+  	{x: @x, y:@y}
+  end
+
+  def inspect
+  	serialize.to_s
+  end
+
+  def to_s
+  	serialize.to_s
+  end
 end
 
-$gtk.schedule_callback 30 do
-  $gtk.console.set_command 'outputs.solids << [910, 200, 100, 100, 255, 0, 0]'
+
+Physics And Collisions - Arbitrary Collision - square_collider.rb
+# ./samples/04_physics_and_collisions/09_arbitrary_collision/app/square_collider.rb
+
+class SquareCollider
+  def initialize x,y,direction,size=COLLISIONWIDTH
+    @x = x
+    @y = y
+    @size = size
+    @direction = direction
+
+  end
+  def collision? args, ball
+    #args.outputs.solids <<  [@x, @y, @size, @size,     000, 255, 255]
+
+
+    return [@x,@y,@size,@size].intersect_rect?([ball.x,ball.y,ball.width,ball.height])
+  end
+
+  def collide args, ball
+    vmag = (ball.velocity.x**2.0 +ball.velocity.y**2.0)**0.5
+    a = ((2.0**0.5)*vmag)/2.0
+    if vmag < MAX_VELOCITY
+      ball.velocity.x = (a) * @direction.x * 1.1
+      ball.velocity.y = (a) * @direction.y * 1.1
+    else
+      ball.velocity.x = (a) * @direction.x
+      ball.velocity.y = (a) * @direction.y
+    end
+
+  end
 end
 
-$gtk.schedule_callback 40 do
-  $gtk.console.eval_the_set_command
+
+Physics And Collisions - Arbitrary Collision - vector2d.rb
+# ./samples/04_physics_and_collisions/09_arbitrary_collision/app/vector2d.rb
+class Vector2d
+    attr_accessor :x, :y
+
+    def initialize x=0, y=0
+      @x=x
+      @y=y
+    end
+
+    #returns a vector multiplied by scalar x
+    #x [float] scalar
+    def mult x
+      r = Vector2d.new(0,0)
+      r.x=@x*x
+      r.y=@y*x
+      r
+    end
+
+    # vect [Vector2d] vector to copy
+    def copy vect
+      Vector2d.new(@x, @y)
+    end
+
+    #returns a new vector equivalent to this+vect
+    #vect [Vector2d] vector to add to self
+    def add vect
+      Vector2d.new(@x+vect.x,@y+vect.y)
+    end
+
+    #returns a new vector equivalent to this-vect
+    #vect [Vector2d] vector to subtract to self
+    def sub vect
+      Vector2d.new(@x-vect.c, @y-vect.y)
+    end
+
+    #return the magnitude of the vector
+    def mag
+      ((@x**2)+(@y**2))**0.5
+    end
+
+    #returns a new normalize version of the vector
+    def normalize
+      Vector2d.new(@x/mag, @y/mag)
+    end
+
+    #TODO delet?
+    def distABS vect
+      (((vect.x-@x)**2+(vect.y-@y)**2)**0.5).abs()
+    end
+  end
+
+Physics And Collisions - Collision With Object Removal - ball.rb
+# ./samples/04_physics_and_collisions/10_collision_with_object_removal/app/ball.rb
+class Ball
+  #TODO limit accessors?
+  attr_accessor :xy, :width, :height, :velocity
+
+
+  #@xy [Vector2d] x,y position
+  #@velocity [Vector2d] velocity of ball
+  def initialize
+    @xy = Vector2d.new(WIDTH/2,500)
+    @velocity = Vector2d.new(4,-4)
+    @width =  20
+    @height = 20
+  end
+
+  #move the ball according to its velocity
+  def update args
+    @xy.x+=@velocity.x
+    @xy.y+=@velocity.y
+  end
+
+  #render the ball to the screen
+  def render args
+    args.outputs.solids << [@xy.x,@xy.y,@width,@height,255,0,255];
+    #args.outputs.labels << [20,HEIGHT-50,"velocity: " +@velocity.x.to_s+","+@velocity.y.to_s + "   magnitude:" + @velocity.mag.to_s]
+  end
+
+  def rect
+    [@xy.x,@xy.y,@width,@height]
+  end
+
 end
 
-$gtk.schedule_callback 50 do
-  $gtk.console.set_command 'outputs.solids << [1010, 200, 100, 100, 0, 0, 255]'
+
+Physics And Collisions - Collision With Object Removal - linear_collider.rb
+# ./samples/04_physics_and_collisions/10_collision_with_object_removal/app/linear_collider.rb
+#The LinearCollider (theoretically) produces collisions upon a line segment defined point.y two x,y cordinates
+
+class LinearCollider
+
+  #start [Array of length 2] start of the line segment as a x,y cordinate
+  #last [Array of length 2] end of the line segment as a x,y cordinate
+
+  #inorder for the LinearCollider to be functional the line segment must be said to have a thickness
+  #(as it is unlikly that a colliding object will land exactly on the linesegment)
+
+  #extension defines if the line's thickness extends negatively or positively
+  #extension :pos     extends positively
+  #extension :neg     extends negatively
+
+  #thickness [float] how thick the line should be (should always be atleast as large as the magnitude of the colliding object)
+  def initialize (pointA, pointB, extension=:neg, thickness=10)
+    @pointA = pointA
+    @pointB = pointB
+    @thickness = thickness
+    @extension = extension
+
+    @pointAExtended={
+      x: @pointA.x + @thickness*(@extension == :neg ? -1 : 1),
+      y: @pointA.y + @thickness*(@extension == :neg ? -1 : 1)
+    }
+    @pointBExtended={
+      x: @pointB.x + @thickness*(@extension == :neg ? -1 : 1),
+      y: @pointB.y + @thickness*(@extension == :neg ? -1 : 1)
+    }
+
+  end
+
+  def resetPoints(pointA,pointB)
+    @pointA = pointA
+    @pointB = pointB
+
+    @pointAExtended={
+      x:@pointA.x + @thickness*(@extension == :neg ? -1 : 1),
+      y:@pointA.y + @thickness*(@extension == :neg ? -1 : 1)
+    }
+    @pointBExtended={
+      x:@pointB.x + @thickness*(@extension == :neg ? -1 : 1),
+      y:@pointB.y + @thickness*(@extension == :neg ? -1 : 1)
+    }
+  end
+
+  #TODO: Ugly function
+  def slope (pointA, pointB)
+    return (pointB.x==pointA.x) ? INFINITY : (pointB.y+-pointA.y)/(pointB.x+-pointA.x)
+  end
+
+  #TODO: Ugly function
+  def intercept(pointA, pointB)
+    if (slope(pointA, pointB) == INFINITY)
+      -INFINITY
+    elsif slope(pointA, pointB) == -1*INFINITY
+      INFINITY
+    else
+      pointA.y+-1.0*(slope(pointA, pointB)*pointA.x)
+    end
+  end
+
+  def calcY(pointA, pointB, x)
+    return slope(pointA, pointB)*x + intercept(pointA, pointB)
+  end
+
+  #test if a collision has occurred
+  def isCollision? (point)
+    #INFINITY slop breaks down when trying to determin collision, ergo it requires a special test
+    if slope(@pointA, @pointB) ==  INFINITY &&
+      point.x >= [@pointA.x,@pointB.x].min+(@extension == :pos ? -@thickness : 0) &&
+      point.x <= [@pointA.x,@pointB.x].max+(@extension == :neg ?  @thickness : 0) &&
+      point.y >= [@pointA.y,@pointB.y].min && point.y <= [@pointA.y,@pointB.y].max
+        return true
+    end
+
+    isNegInLine   = @extension == :neg &&
+                    point.y <= slope(@pointA, @pointB)*point.x+intercept(@pointA,@pointB) &&
+                    point.y >= point.x*slope(@pointAExtended, @pointBExtended)+intercept(@pointAExtended,@pointBExtended)
+    isPosInLine   = @extension == :pos &&
+                    point.y >= slope(@pointA, @pointB)*point.x+intercept(@pointA,@pointB) &&
+                    point.y <= point.x*slope(@pointAExtended, @pointBExtended)+intercept(@pointAExtended,@pointBExtended)
+    isInBoxBounds = point.x >= [@pointA.x,@pointB.x].min &&
+                    point.x <= [@pointA.x,@pointB.x].max &&
+                    point.y >= [@pointA.y,@pointB.y].min+(@extension == :neg ? -@thickness : 0) &&
+                    point.y <= [@pointA.y,@pointB.y].max+(@extension == :pos ? @thickness : 0)
+
+    return isInBoxBounds && (isNegInLine || isPosInLine)
+
+  end
+
+  def getRepelMagnitude (fbx, fby, vrx, vry, args)
+    a = fbx ; b = vrx ; c = fby
+    d = vry ; e = args.state.ball.velocity.mag
+
+    if b**2 + d**2 == 0
+      puts "magnitude error"
+    end
+
+    x1 = (-a*b+-c*d + (e**2 * b**2 - b**2 * c**2 + 2*a*b*c*d + e**2 + d**2 - a**2 * d**2)**0.5)/(b**2 + d**2)
+    x2 = -((a*b + c*d + (e**2 * b**2 - b**2 * c**2 + 2*a*b*c*d + e**2 * d**2 - a**2 * d**2)**0.5)/(b**2 + d**2))
+    return ((a+x1*b)**2 + (c+x1*d)**2 == e**2) ? x1 : x2
+  end
+
+  def update args
+    #each of the four points on the square ball - NOTE simple to extend to a circle
+    points= [ {x: args.state.ball.xy.x,                          y: args.state.ball.xy.y},
+              {x: args.state.ball.xy.x+args.state.ball.width,    y: args.state.ball.xy.y},
+              {x: args.state.ball.xy.x,                          y: args.state.ball.xy.y+args.state.ball.height},
+              {x: args.state.ball.xy.x+args.state.ball.width,    y: args.state.ball.xy.y + args.state.ball.height}
+            ]
+
+    #for each point p in points
+    for point in points
+      #isCollision.md has more information on this section
+      #TODO: section can certainly be simplifyed
+      if isCollision?(point)
+        u = Vector2d.new(1.0,((slope(@pointA, @pointB)==0) ? INFINITY : -1/slope(@pointA, @pointB))*1.0).normalize #normal perpendicular (to line segment) vector
+
+        #the vector with the repeling force can be u or -u depending of where the ball was coming from in relation to the line segment
+        previousBallPosition=Vector2d.new(point.x-args.state.ball.velocity.x,point.y-args.state.ball.velocity.y)
+        choiceA = (u.mult(1))
+        choiceB =  (u.mult(-1))
+        vectorRepel = nil
+
+        if (slope(@pointA, @pointB))!=INFINITY && u.y < 0
+          choiceA, choiceB = choiceB, choiceA
+        end
+        vectorRepel = (previousBallPosition.y > calcY(@pointA, @pointB, previousBallPosition.x)) ? choiceA : choiceB
+
+        #vectorRepel = (previousBallPosition.y > slope(@pointA, @pointB)*previousBallPosition.x+intercept(@pointA,@pointB)) ? choiceA : choiceB)
+        if (slope(@pointA, @pointB) == INFINITY) #slope INFINITY breaks down in the above test, ergo it requires a custom test
+          vectorRepel = (previousBallPosition.x > @pointA.x) ? (u.mult(1)) : (u.mult(-1))
+        end
+        #puts ("     " + $t[0].to_s + "," + $t[1].to_s + "    " + $t[2].to_s + "," + $t[3].to_s + "     " + "   " + u.x.to_s + "," + u.y.to_s)
+        #vectorRepel now has the repeling force
+
+        mag = args.state.ball.velocity.mag
+        theta_ball=Math.atan2(args.state.ball.velocity.y,args.state.ball.velocity.x) #the angle of the ball's velocity
+        theta_repel=Math.atan2(vectorRepel.y,vectorRepel.x) #the angle of the repeling force
+        #puts ("theta:" + theta_ball.to_s + " " + theta_repel.to_s) #theta okay
+
+        fbx = mag * Math.cos(theta_ball) #the x component of the ball's velocity
+        fby = mag * Math.sin(theta_ball) #the y component of the ball's velocity
+
+        repelMag = getRepelMagnitude(fbx, fby, vectorRepel.x, vectorRepel.y, args)
+
+        frx = repelMag* Math.cos(theta_repel) #the x component of the repel's velocity | magnitude is set to twice of fbx
+        fry = repelMag* Math.sin(theta_repel) #the y component of the repel's velocity | magnitude is set to twice of fby
+
+        fsumx = fbx+frx #sum of x forces
+        fsumy = fby+fry #sum of y forces
+        fr = mag#fr is the resulting magnitude
+        thetaNew = Math.atan2(fsumy, fsumx)  #thetaNew is the resulting angle
+        xnew = fr*Math.cos(thetaNew) #resulting x velocity
+        ynew = fr*Math.sin(thetaNew) #resulting y velocity
+
+        args.state.ball.velocity = Vector2d.new(xnew,ynew)
+        #args.state.ball.xy.add(args.state.ball.velocity)
+        break #no need to check the other points ?
+      else
+      end
+    end
+  end #end update
+
 end
 
-$gtk.schedule_callback 60 do
-  $gtk.console.eval_the_set_command
+
+Physics And Collisions - Collision With Object Removal - main.rb
+# ./samples/04_physics_and_collisions/10_collision_with_object_removal/app/main.rb
+# coding: utf-8
+INFINITY= 10**10
+WIDTH=1280
+HEIGHT=720
+
+require 'app/vector2d.rb'
+require 'app/paddle.rb'
+require 'app/ball.rb'
+require 'app/linear_collider.rb'
+
+#Method to init default values
+def defaults args
+  args.state.game_board ||= [(args.grid.w / 2 - args.grid.w / 4), 0, (args.grid.w / 2), args.grid.h]
+  args.state.bricks ||= []
+  args.state.num_bricks ||= 0
+  args.state.game_over_at ||= 0
+  args.state.paddle ||= Paddle.new
+  args.state.ball   ||= Ball.new
+  args.state.westWall  ||= LinearCollider.new({x: args.grid.w/4,      y: 0},          {x: args.grid.w/4,      y: args.grid.h}, :pos)
+  args.state.eastWall  ||= LinearCollider.new({x: 3*args.grid.w*0.25, y: 0},          {x: 3*args.grid.w*0.25, y: args.grid.h})
+  args.state.southWall ||= LinearCollider.new({x: 0,                  y: 0},          {x: args.grid.w,        y: 0})
+  args.state.northWall ||= LinearCollider.new({x: 0,                  y:args.grid.h}, {x: args.grid.w,        y: args.grid.h}, :pos)
+
+  #args.state.testWall ||= LinearCollider.new({x:0 , y:0},{x:args.grid.w, y:args.grid.h})
 end
 
-$gtk.schedule_callback 70 do
-  $gtk.console.set_command 'outputs.sprites << [1110, 200, 100, 100, "sprites/dragon_fly_0.png"]'
+#Render loop
+def render args
+  render_instructions args
+  render_board args
+  render_bricks args
 end
 
-$gtk.schedule_callback 80 do
-  $gtk.console.eval_the_set_command
+begin :render_methods
+  #Method to display the instructions of the game
+  def render_instructions args
+    args.outputs.labels << [225, args.grid.h - 30, "← and → to move the paddle left and right",  0, 1]
+  end
+
+  def render_board args
+    args.outputs.borders << args.state.game_board
+  end
+
+  def render_bricks args
+    args.outputs.solids << args.state.bricks.map(&:rect)
+  end
 end
 
-$gtk.schedule_callback 90 do
-  $gtk.console.set_command "outputs.labels << [1210, 200, state.tick_count, 0, 255, 0]"
+#Calls all methods necessary for performing calculations
+def calc args
+  add_new_bricks args
+  reset_game args
+  calc_collision args
+  win_game args
+
+  args.state.westWall.update args
+  args.state.eastWall.update args
+  args.state.southWall.update args
+  args.state.northWall.update args
+  args.state.paddle.update args
+  args.state.ball.update args
+
+  #args.state.testWall.update args
+
+  args.state.paddle.render args
+  args.state.ball.render args
 end
 
-$gtk.schedule_callback 100 do
-  $gtk.console.eval_the_set_command
+begin :calc_methods
+  def add_new_bricks args
+    return if args.state.num_bricks > 40
+
+    #Width of the game board is 640px
+    brick_width = (args.grid.w / 2) / 10
+    brick_height = brick_width / 2
+
+    (4).map_with_index do |y|
+      #Make a box that is 10 bricks wide and 4 bricks tall
+      args.state.bricks += (10).map_with_index do |x|
+        args.state.new_entity(:brick) do |b|
+          b.x = x * brick_width + (args.grid.w / 2 - args.grid.w / 4)
+          b.y = args.grid.h - ((y + 1) * brick_height)
+          b.rect = [b.x + 1, b.y - 1, brick_width - 2, brick_height - 2, 235, 50 * y, 52]
+
+          #Add linear colliders to the brick
+          b.collider_bottom = LinearCollider.new([(b.x-2), (b.y-5)], [(b.x+brick_width+1), (b.y-5)], :pos, brick_height)
+          b.collider_right = LinearCollider.new([(b.x+brick_width+1), (b.y-5)], [(b.x+brick_width+1), (b.y+brick_height+1)], :pos)
+          b.collider_left = LinearCollider.new([(b.x-2), (b.y-5)], [(b.x-2), (b.y+brick_height+1)], :neg)
+          b.collider_top = LinearCollider.new([(b.x-2), (b.y+brick_height+1)], [(b.x+brick_width+1), (b.y+brick_height+1)], :neg)
+
+          # @xyCollision  = LinearCollider.new({x: @x,y: @y+@height}, {x: @x+@width, y: @y+@height})
+          # @xyCollision2 = LinearCollider.new({x: @x,y: @y}, {x: @x+@width, y: @y}, :pos)
+          # @xyCollision3 = LinearCollider.new({x: @x,y: @y}, {x: @x, y: @y+@height})
+          # @xyCollision4 = LinearCollider.new({x: @x+@width,y: @y}, {x: @x+@width, y: @y+@height}, :pos)
+
+          b.broken = false
+
+          args.state.num_bricks += 1
+        end
+      end
+    end
+  end
+
+  def reset_game args
+    if args.state.ball.xy.y < 20 && args.state.game_over_at.elapsed_time > 60
+      #Freeze the ball
+      args.state.ball.velocity.x = 0
+      args.state.ball.velocity.y = 0
+      #Freeze the paddle
+      args.state.paddle.enabled = false
+
+      args.state.game_over_at = args.state.tick_count
+    end
+
+    if args.state.game_over_at.elapsed_time < 60 && args.state.tick_count > 60 && args.state.bricks.count != 0
+      #Display a "Game over" message
+      args.outputs.labels << [100, 100, "GAME OVER", 10]
+    end
+
+    #If 60 frames have passed since the game ended, restart the game
+    if args.state.game_over_at != 0 && args.state.game_over_at.elapsed_time == 60
+      # FIXME: only put value types in state
+      args.state.ball = Ball.new
+
+      # FIXME: only put value types in state
+      args.state.paddle = Paddle.new
+
+      args.state.bricks = []
+      args.state.num_bricks = 0
+    end
+  end
+
+  def calc_collision args
+    #Remove the brick if it is hit with the ball
+    ball = args.state.ball
+    ball_rect = [ball.xy.x, ball.xy.y, 20, 20]
+
+    #Loop through each brick to see if the ball is colliding with it
+    args.state.bricks.each do |b|
+      if b.rect.intersect_rect?(ball_rect)
+        #Run the linear collider for the brick if there is a collision
+        b[:collider_bottom].update args
+        b[:collider_right].update args
+        b[:collider_left].update args
+        b[:collider_top].update args
+
+        b.broken = true
+      end
+    end
+
+    args.state.bricks = args.state.bricks.reject(&:broken)
+  end
+
+  def win_game args
+    if args.state.bricks.count == 0 && args.state.game_over_at.elapsed_time > 60
+      #Freeze the ball
+      args.state.ball.velocity.x = 0
+      args.state.ball.velocity.y = 0
+      #Freeze the paddle
+      args.state.paddle.enabled = false
+
+      args.state.game_over_at = args.state.tick_count
+    end
+
+    if args.state.game_over_at.elapsed_time < 60 && args.state.tick_count > 60 && args.state.bricks.count == 0
+      #Display a "Game over" message
+      args.outputs.labels << [100, 100, "CONGRATULATIONS!", 10]
+    end
+  end
+
 end
 
-$gtk.schedule_callback 110 do
-  $gtk.console.set_command "state.sprite_frame = state.tick_count.idiv(4).mod(6)"
+def tick args
+  defaults args
+  render args
+  calc args
+
+  #args.outputs.lines << [0, 0, args.grid.w, args.grid.h]
+
+  #$tc+=1
+  #if $tc == 5
+    #$train << [args.state.ball.xy.x, args.state.ball.xy.y]
+    #$tc = 0
+  #end
+  #for t in $train
+
+    #args.outputs.solids << [t[0],t[1],5,5,255,0,0];
+  #end
 end
 
-$gtk.schedule_callback 120 do
-  $gtk.console.eval_the_set_command
+
+Physics And Collisions - Collision With Object Removal - paddle.rb
+# ./samples/04_physics_and_collisions/10_collision_with_object_removal/app/paddle.rb
+class Paddle
+  attr_accessor :enabled
+
+  def initialize ()
+    @x=WIDTH/2
+    @y=100
+    @width=100
+    @height=20
+    @speed=10
+
+    @xyCollision  = LinearCollider.new({x: @x,y: @y+@height+5}, {x: @x+@width, y: @y+@height+5})
+    @xyCollision2 = LinearCollider.new({x: @x,y: @y}, {x: @x+@width, y: @y}, :pos)
+    @xyCollision3 = LinearCollider.new({x: @x,y: @y}, {x: @x, y: @y+@height+5})
+    @xyCollision4 = LinearCollider.new({x: @x+@width,y: @y}, {x: @x+@width, y: @y+@height+5}, :pos)
+
+    @enabled = true
+  end
+
+  def update args
+    @xyCollision.resetPoints({x: @x,y: @y+@height+5}, {x: @x+@width, y: @y+@height+5})
+    @xyCollision2.resetPoints({x: @x,y: @y}, {x: @x+@width, y: @y})
+    @xyCollision3.resetPoints({x: @x,y: @y}, {x: @x, y: @y+@height+5})
+    @xyCollision4.resetPoints({x: @x+@width,y: @y}, {x: @x+@width, y: @y+@height+5})
+
+    @xyCollision.update  args
+    @xyCollision2.update args
+    @xyCollision3.update args
+    @xyCollision4.update args
+
+    args.inputs.keyboard.key_held.left  ||= false
+    args.inputs.keyboard.key_held.right  ||= false
+
+    if not (args.inputs.keyboard.key_held.left == args.inputs.keyboard.key_held.right)
+      if args.inputs.keyboard.key_held.left && @enabled
+        @x-=@speed
+      elsif args.inputs.keyboard.key_held.right && @enabled
+        @x+=@speed
+      end
+    end
+
+    xmin =WIDTH/4
+    xmax = 3*(WIDTH/4)
+    @x = (@x+@width > xmax) ? xmax-@width : (@x

+Physics And Collisions - Collision With Object Removal - tests.rb
+# ./samples/04_physics_and_collisions/10_collision_with_object_removal/app/tests.rb
+# For advanced users:
+# You can put some quick verification tests here, any method
+# that starts with the `test_` will be run when you save this file.
+
+# Here is an example test and game
+
+# To run the test: ./dragonruby mygame --eval app/tests.rb --no-tick
+
+class MySuperHappyFunGame
+  attr_gtk
+
+  def tick
+    outputs.solids << [100, 100, 300, 300]
+  end
 end
 
-$gtk.schedule_callback 140 do
-  $gtk.console.eval_the_set_command
+def test_universe args, assert
+  game = MySuperHappyFunGame.new
+  game.args = args
+  game.tick
+  assert.true!  args.outputs.solids.length == 1, "failure: a solid was not added after tick"
+  assert.false! 1 == 2, "failure: some how, 1 equals 2, the world is ending"
+  puts "test_universe completed successfully"
 end
 
-$gtk.schedule_callback 150 do
-  $gtk.console.set_command "state.sprite_path =  \"sprites/dragon_fly_\#{state.sprite_frame}.png\""
+puts "running tests"
+$gtk.reset 100
+$gtk.log_level = :off
+$gtk.tests.start
+
+
+Physics And Collisions - Collision With Object Removal - vector2d.rb
+# ./samples/04_physics_and_collisions/10_collision_with_object_removal/app/vector2d.rb
+
+class Vector2d
+  attr_accessor :x, :y
+
+  def initialize x=0, y=0
+    @x=x
+    @y=y
+  end
+
+  #returns a vector multiplied by scalar x
+  #x [float] scalar
+  def mult x
+    r = Vector2d.new(0,0)
+    r.x=@x*x
+    r.y=@y*x
+    r
+  end
+
+  # vect [Vector2d] vector to copy
+  def copy vect
+    Vector2d.new(@x, @y)
+  end
+
+  #returns a new vector equivalent to this+vect
+  #vect [Vector2d] vector to add to self
+  def add vect
+    Vector2d.new(@x+vect.x,@y+vect.y)
+  end
+
+  #returns a new vector equivalent to this-vect
+  #vect [Vector2d] vector to subtract to self
+  def sub vect
+    Vector2d.new(@x-vect.c, @y-vect.y)
+  end
+
+  #return the magnitude of the vector
+  def mag
+    ((@x**2)+(@y**2))**0.5
+  end
+
+  #returns a new normalize version of the vector
+  def normalize
+    Vector2d.new(@x/mag, @y/mag)
+  end
+
+  #TODO delet?
+  def distABS vect
+    (((vect.x-@x)**2+(vect.y-@y)**2)**0.5).abs()
+  end
 end
 
-$gtk.schedule_callback 160 do
-  $gtk.console.eval_the_set_command
-end
+
+Mouse - Mouse Click - main.rb
+# ./samples/05_mouse/01_mouse_click/app/main.rb
+=begin
+
+ APIs listing that haven't been encountered in previous sample apps:
+
+ - product: Returns an array of all combinations of elements from all arrays.
+
+   For example, [1,2].product([1,2]) would return the following array...
+   [[1,1], [1,2], [2,1], [2,2]]
+   More than two arrays can be given to product and it will still work,
+   such as [1,2].product([1,2],[3,4]). What would product return in this case?
+
+   Answer:
+   [[1,1,3],[1,1,4],[1,2,3],[1,2,4],[2,1,3],[2,1,4],[2,2,3],[2,2,4]]
+
+ - num1.fdiv(num2): Returns the float division (will have a decimal) of the two given numbers.
+   For example, 5.fdiv(2) = 2.5 and 5.fdiv(5) = 1.0
+
+ - yield: Allows you to call a method with a code block and yield to that block.
+
+ Reminders:
+
+ - ARRAY#inside_rect?: Returns true or false depending on if the point is inside the rect.
+
+ - String interpolation: Uses #{} syntax; everything between the #{ and the } is evaluated
+   as Ruby code, and the placeholder is replaced with its corresponding value or result.
+
+ - args.inputs.mouse.click: This property will be set if the mouse was clicked.
+
+ - Ternary operator (?): Will evaluate a statement (just like an if statement)
+   and perform an action if the result is true or another action if it is false.
+
+ - reject: Removes elements from a collection if they meet certain requirements.
+
+ - args.outputs.borders: An array. The values generate a border.
+   The parameters are [X, Y, WIDTH, HEIGHT, RED, GREEN, BLUE]
+   For more information about borders, go to mygame/documentation/03-solids-and-borders.md.
 
-$gtk.schedule_callback 170 do
-  $gtk.console.set_command "outputs.labels    << [910, 330, \"path: \#{state.sprite_path}\", 0, 255, 0]"
-end
+ - args.outputs.labels: An array. The values generate a label.
+   The parameters are [X, Y, TEXT, SIZE, ALIGNMENT, RED, GREEN, BLUE, ALPHA, FONT STYLE]
+   For more information about labels, go to mygame/documentation/02-labels.
 
-$gtk.schedule_callback 180 do
-  $gtk.console.eval_the_set_command
-end
+=end
 
-$gtk.schedule_callback 190 do
-  $gtk.console.set_command "outputs.sprites   << [910, 330, 370, 370, state.sprite_path]"
-end
+# This sample app is a classic game of Tic Tac Toe.
 
-$gtk.schedule_callback 200 do
-  $gtk.console.eval_the_set_command
-end
+class TicTacToe
+  attr_accessor :_, :state, :outputs, :inputs, :grid, :gtk
 
-$gtk.schedule_callback 300 do
-  $gtk.console.set_command ":wq"
-end
+  # Starts the game with player x's turn and creates an array (to_a) for space combinations.
+  # Calls methods necessary for the game to run properly.
+  def tick
+    state.current_turn ||= :x
+    state.space_combinations = [-1, 0, 1].product([-1, 0, 1]).to_a
+    render_board
+    input_board
+  end
 
-$gtk.schedule_callback 400 do
-  $gtk.console.eval_the_set_command
-end
+  # Uses borders to create grid squares for the game's board. Also outputs the game pieces using labels.
+  def render_board
+    square_size = 80
 
-

-Learn Ruby Optional - Beginner Ruby Primer - main.rb
-# ./samples/00_learn_ruby_optional/00_beginner_ruby_primer/app/main.rb
-# ==========================================================================
-#  _    _ ________     __  _      _____  _____ _______ ______ _   _ _ _ _ _
-# | |  | |  ____\ \   / / | |    |_   _|/ ____|__   __|  ____| \ | | | | | |
-# | |__| | |__   \ \_/ /  | |      | | | (___    | |  | |__  |  \| | | | | |
-# |  __  |  __|   \   /   | |      | |  \___ \   | |  |  __| | . ` | | | | |
-# | |  | | |____   | |    | |____ _| |_ ____) |  | |  | |____| |\  |_|_|_|_|
-# |_|  |_|______|  |_|    |______|_____|_____/   |_|  |______|_| \_(_|_|_|_)
-#
-#
-#                                   |
-#                                   |
-#                                   |
-#                                   |
-#                                   |
-#                                   |
-#                                   |
-#                                   |
-#                                   |
-#                                   |
-#                                \  |  /
-#                                 \ | /
-#                                   +
-#
-# If you are new to the programming language Ruby, then you may find the
-# following code a bit overwhelming. This sample is only designed to be
-# run interactively (as opposed to being manipulated via source code).
-#
-# Start up this sample and follow along by visiting:
-# https://s3.amazonaws.com/s3.dragonruby.org/dragonruby-gtk-primer.mp4
-#
-# It is STRONGLY recommended that you work through all the samples before
-# looking at the code in this file.
-# ==========================================================================
+    # Positions the game's board in the center of the screen.
+    # Try removing what follows grid.w_half or grid.h_half and see how the position changes!
+    board_left = grid.w_half - square_size * 1.5
+    board_top  = grid.h_half - square_size * 1.5
 
-class TutorialOutputs
-  attr_accessor :solids, :sprites, :labels, :lines, :borders
+    # At first glance, the add(1) looks pretty trivial. But if you remove it,
+    # you'll see that the positioning of the board would be skewed without it!
+    # Or if you put 2 in the parenthesis, the pieces will be placed in the wrong squares
+    # due to the change in board placement.
+    outputs.borders << all_spaces do |x, y, space| # outputs borders for all board spaces
+      space.border ||= [
+        board_left + x.add(1) * square_size, # space.border is initialized using this definition
+        board_top  + y.add(1) * square_size,
+        square_size,
+        square_size
+      ]
+    end
 
-  def initialize
-    @solids  = []
-    @sprites = []
-    @labels  = []
-    @lines   = []
-    @borders = []
-  end
+    # Again, the calculations ensure that the piece is placed in the center of the grid square.
+    # Remove the '- 20' and the piece will be placed at the top of the grid square instead of the center.
+    outputs.labels << filled_spaces do |x, y, space| # put label in each filled space of board
+          label board_left + x.add(1) * square_size + square_size.fdiv(2),
+          board_top  + y.add(1) * square_size + square_size - 20,
+          space.piece # text of label, either "x" or "o"
+    end
 
-  def tick
-    @solids  ||= []
-    @sprites ||= []
-    @labels  ||= []
-    @lines   ||= []
-    @borders ||= []
-    @solids.each  { |p| $gtk.args.outputs.reserved << p.solid  }
-    @sprites.each { |p| $gtk.args.outputs.reserved << p.sprite }
-    @labels.each  { |p| $gtk.args.outputs.reserved << p.label  }
-    @lines.each   { |p| $gtk.args.outputs.reserved << p.line   }
-    @borders.each { |p| $gtk.args.outputs.reserved << p.border }
+    # Uses a label to output whether x or o won, or if a draw occurred.
+    # If the game is ongoing, a label shows whose turn it currently is.
+    outputs.labels << if state.x_won
+                        label grid.w_half, grid.top - 80, "x won" # the '-80' positions the label 80 pixels lower than top
+                      elsif state.o_won
+                        label grid.w_half, grid.top - 80, "o won" # grid.w_half positions the label in the center horizontally
+                      elsif state.draw
+                        label grid.w_half, grid.top - 80, "a draw"
+                      else # if no one won and the game is ongoing
+                        label grid.w_half, grid.top - 80, "turn: #{state.current_turn}"
+                      end
   end
 
-  def clear
-    @solids.clear
-    @sprites.clear
-    @labels.clear
-    @borders.clear
+  # Calls the methods responsible for handling user input and determining the winner.
+  # Does nothing unless the mouse is clicked.
+  def input_board
+    return unless inputs.mouse.click
+    input_place_piece
+    input_restart_game
+    determine_winner
   end
-end
 
-def defaults
-  state.reset_button ||=
-    state.new_entity(
-      :button,
-      label:  [1190, 68, "RESTART", -2, 0, 0, 0, 0].label,
-      background: [1160, 38, 120, 50, 255, 255, 255].solid
-    )
-  $gtk.log_level = :off
-end
+  # Handles user input for placing pieces on the board.
+  def input_place_piece
+    return if state.game_over
 
-def tick_reset_button
-  return unless state.hello_dragonruby_confirmed
-  $gtk.args.outputs.reserved << state.reset_button.background
-  $gtk.args.outputs.reserved << state.reset_button.label
-  if inputs.mouse.click && inputs.mouse.click.point.inside_rect?(state.reset_button.background)
-    restart_tutorial
-  end
-end
+    # Checks to find the space that the mouse was clicked inside of, and makes sure the space does not already
+    # have a piece in it.
+    __, __, space = all_spaces.find do |__, __, space|
+      inputs.mouse.click.point.inside_rect?(space.border) && !space.piece
+    end
 
-def seperator
-  @seperator = "=" * 80
-end
+    # The piece that goes into the space belongs to the player whose turn it currently is.
+    return unless space
+    space.piece = state.current_turn
 
-def tick_intro
-  queue_message "Welcome to the DragonRuby GTK primer! Try typing the
-code below and press ENTER:
+    # This ternary operator statement allows us to change the current player's turn.
+    # If it is currently x's turn, it becomes o's turn. If it is not x's turn, it become's x's turn.
+    state.current_turn = state.current_turn == :x ? :o : :x
+  end
 
-    puts \"Hello DragonRuby!\"
-"
-end
+  # Resets the game.
+  def input_restart_game
+    return unless state.game_over
+    gtk.reset
+  end
 
-def tick_hello_dragonruby
-  return unless console_has? "Hello DragonRuby!"
+  # Checks if x or o won the game.
+  # If neither player wins and all nine squares are filled, a draw happens.
+  # Once a player is chosen as the winner or a draw happens, the game is over.
+  def determine_winner
+    state.x_won = won? :x # evaluates to either true or false (boolean values)
+    state.o_won = won? :o
+    state.draw = true if filled_spaces.length == 9 && !state.x_won && !state.o_won
+    state.game_over = state.x_won || state.o_won || state.draw
+  end
 
-  $gtk.args.state.hello_dragonruby_confirmed = true
+  # Determines if a player won by checking if there is a horizontal match or vertical match.
+  # Horizontal_match and vertical_match have boolean values. If either is true, the game has been won.
+  def won? piece
+    # performs action on all space combinations
+    won = [[-1, 0, 1]].product([-1, 0, 1]).map do |xs, y|
 
-  queue_message "Well HELLO to you too!
+      # Checks if the 3 grid spaces with the same y value (or same row) and
+      # x values that are next to each other have pieces that belong to the same player.
+      # Remember, the value of piece is equal to the current turn (which is the player).
+      horizontal_match = state.spaces[xs[0]][y].piece == piece &&
+                         state.spaces[xs[1]][y].piece == piece &&
+                         state.spaces[xs[2]][y].piece == piece
 
-If you ever want to RESTART the tutorial, just click the \"RESTART\"
-button in the bottom right-hand corner.
+      # Checks if the 3 grid spaces with the same x value (or same column) and
+      # y values that are next to each other have pieces that belong to the same player.
+      # The && represents an "and" statement: if even one part of the statement is false,
+      # the entire statement evaluates to false.
+      vertical_match = state.spaces[y][xs[0]].piece == piece &&
+                       state.spaces[y][xs[1]].piece == piece &&
+                       state.spaces[y][xs[2]].piece == piece
 
-Let's continue shall we? Type the code below and press ENTER:
+      horizontal_match || vertical_match # if either is true, true is returned
+    end
 
-    outputs.solids << [910, 200, 100, 100, 255, 0, 0]
-"
+    # Sees if there is a diagonal match, starting from the bottom left and ending at the top right.
+    # Is added to won regardless of whether the statement is true or false.
+    won << (state.spaces[-1][-1].piece == piece && # bottom left
+            state.spaces[ 0][ 0].piece == piece && # center
+            state.spaces[ 1][ 1].piece == piece)   # top right
 
-end
+    # Sees if there is a diagonal match, starting at the bottom right and ending at the top left
+    # and is added to won.
+    won << (state.spaces[ 1][-1].piece == piece && # bottom right
+            state.spaces[ 0][ 0].piece == piece && # center
+            state.spaces[-1][ 1].piece == piece)   # top left
 
-def tick_explain_solid
-  return unless $tutorial_outputs.solids.any? {|s| s == [910, 200, 100, 100, 255, 0, 0]}
+    # Any false statements (meaning false diagonal matches) are rejected from won
+    won.reject_false.any?
+  end
+
+  # Defines filled spaces on the board by rejecting all spaces that do not have game pieces in them.
+  # The ! before a statement means "not". For example, we are rejecting any space combinations that do
+  # NOT have pieces in them.
+  def filled_spaces
+    state.space_combinations
+      .reject { |x, y| !state.spaces[x][y].piece } # reject spaces with no pieces in them
+      .map do |x, y|
+        if block_given?
+          yield x, y, state.spaces[x][y]
+        else
+          [x, y, state.spaces[x][y]] # sets definition of space
+        end
+    end
+  end
 
-  queue_message "Sweet!
+  # Defines all spaces on the board.
+  def all_spaces
+    if !block_given?
+      state.space_combinations.map do |x, y|
+        [x, y, state.spaces[x][y]] # sets definition of space
+      end
+    else # if a block is given (block_given? is true)
+      state.space_combinations.map do |x, y|
+        yield x, y, state.spaces[x][y] # yield if a block is given
+      end
+    end
+  end
 
-The code: outputs.solids << [910, 200, 100, 100, 255, 0, 0]
-Does the following:
-1. GET the place where SOLIDS go: outputs.solids
-2. Request that a new SOLID be ADDED: <<
-3. The DEFINITION of a SOLID is the ARRAY:
-   [910, 200, 100, 100, 255, 0, 0]
+  # Sets values for a label, such as the position, value, size, alignment, and color.
+  def label x, y, value
+    [x, y + 10, value, 20, 1, 0, 0, 0]
+  end
+end
 
-      GET       ADD     X      Y    WIDTH  HEIGHT RED  GREEN  BLUE
-       |         |      |      |      |      |     |     |     |
-       |         |      |      |      |      |     |     |     |
-outputs.solids  <<    [910,   200,   100,   100,  255,   0,    0]
-                      |_________________________________________|
-                                           |
-                                           |
-                                         ARRAY
+$tic_tac_toe = TicTacToe.new
 
-Now let's create a blue SOLID. Type:
+def tick args
+  $tic_tac_toe._       = args
+  $tic_tac_toe.state   = args.state
+  $tic_tac_toe.outputs = args.outputs
+  $tic_tac_toe.inputs  = args.inputs
+  $tic_tac_toe.grid    = args.grid
+  $tic_tac_toe.gtk     = args.gtk
+  $tic_tac_toe.tick
+  tick_instructions args, "Sample app shows how to work with mouse clicks."
+end
 
-    outputs.solids << [1010, 200, 100, 100, 0, 0, 255]
-"
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
+  end
 
-  state.explain_solid_confirmed = true
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
 end
 
-def tick_explain_solid_blue
-  return unless state.explain_solid_confirmed
-  return unless $tutorial_outputs.solids.any? {|s| s == [1010, 200, 100, 100, 0, 0, 255]}
-  state.explain_solid_blue_confirmed = true
+
+Mouse - Mouse Move - main.rb
+# ./samples/05_mouse/02_mouse_move/app/main.rb
+=begin
 
-  queue_message "And there is our blue SOLID!
+ Reminders:
 
-The ARRAY is the MOST important thing in DragonRuby GTK.
+ - num1.greater(num2): Returns the greater value.
+   For example, if we have the command
+   puts 4.greater(3)
+   the number 4 would be printed to the console since it has a greater value than 3.
+   Similar to lesser, which returns the lesser value.
 
-Let's create a SPRITE using an ARRAY:
+ - find_all: Finds all elements of a collection that meet certain requirements.
+   For example, in this sample app, we're using find_all to find all zombies that have intersected
+   or hit the player's sprite since these zombies have been killed.
 
-  outputs.sprites << [1110, 200, 100, 100, 'sprites/dragon_fly_0.png']
-"
-end
+ - args.inputs.keyboard.key_down.KEY: Determines if a key is being held or pressed.
+   Stores the frame the "down" event occurred.
+   For more information about the keyboard, go to mygame/documentation/06-keyboard.md.
 
-def tick_explain_tick_count
-  return unless $tutorial_outputs.sprites.any? {|s| s == [1110, 200, 100, 100, 'sprites/dragon_fly_0.png']}
-  return if $tutorial_outputs.labels.any? {|l| l == [1210, 200, state.tick_count, 255, 255, 255]}
-  state.explain_tick_count_confirmed = true
+ - args.outputs.sprites: An array. The values generate a sprite.
+   The parameters are [X, Y, WIDTH, HEIGHT, PATH, ANGLE, ALPHA, RED, GREEN, BLUE]
+   For more information about sprites, go to mygame/documentation/05-sprites.md.
 
-  queue_message "Look at the cute little dragon!
+ - args.state.new_entity: Used when we want to create a new object, like a sprite or button.
+   When we want to create a new object, we can declare it as a new entity and then define
+   its properties. (Remember, you can use state to define ANY property and it will
+   be retained across frames.)
 
-We can create a LABEL with ARRAYS too. Let's create a LABEL showing
-THE PASSAGE OF TIME, which is called TICK_COUNT.
+ - String interpolation: Uses #{} syntax; everything between the #{ and the } is evaluated
+   as Ruby code, and the placeholder is replaced with its corresponding value or result.
 
-  outputs.labels << [1210, 200, state.tick_count, 0, 255, 0]
-"
-end
+ - map: Ruby method used to transform data; used in arrays, hashes, and collections.
+   Can be used to perform an action on every element of a collection, such as multiplying
+   each element by 2 or declaring every element as a new entity.
 
-def tick_explain_mod
-  return unless $tutorial_outputs.labels.any? {|l| l == [1210, 200, state.tick_count, 0, 255, 0]}
-  state.explain_mod_confirmed = true
-  queue_message "
-The code: outputs.labels << [1210, 200, state.tick_count, 0, 255, 0]
-Does the following:
-1. GET the place where labels go: outputs.labels
-2. Request that a new label be ADDED: <<
-3. The DEFINITION of a LABEL is the ARRAY:
-   [1210, 200, state.tick_count, 0, 255, 0]
+ - sample: Chooses a random element from the array.
 
-      GET       ADD     X      Y          TEXT         RED  GREEN  BLUE
-       |         |      |      |            |           |     |     |
-       |         |      |      |            |           |     |     |
-outputs.labels  <<    [1210,  200,   state.tick_count,  0,   255,   0]
-                      |______________________________________________|
-                                              |
-                                              |
-                                            ARRAY
+ - reject: Removes elements that meet certain requirements.
+   In this sample app, we're removing/rejecting zombies that reach the center of the screen. We're also
+   rejecting zombies that were killed more than 30 frames ago.
 
-Now let's do some MATH, save the result to STATE, and create a LABEL:
+=end
 
-    state.sprite_frame = state.tick_count.idiv(4).mod(6)
-    outputs.labels << [1210, 170, state.sprite_frame, 0, 255, 0]
+# This sample app allows users to move around the screen in order to kill zombies. Zombies appear from every direction so the goal
+# is to kill the zombies as fast as possible!
 
-Type the lines above (pressing ENTER after each line).
-"
-end
+class ProtectThePuppiesFromTheZombies
+  attr_accessor :grid, :inputs, :state, :outputs
 
-def tick_explain_string_interpolation
-  return unless state.explain_mod_confirmed
-  return unless state.sprite_frame == state.tick_count.idiv(4).mod(6)
-  return unless $tutorial_outputs.labels.any? {|l| l == [1210, 170, state.sprite_frame, 0, 255, 0]}
+  # Calls the methods necessary for the game to run properly.
+  def tick
+    defaults
+    render
+    calc
+    input
+  end
 
-  queue_message "Here is what the mathematical computation you just typed does:
+  # Sets default values for the zombies and for the player.
+  # Initialization happens only in the first frame.
+  def defaults
+    state.flash_at               ||= 0
+    state.zombie_min_spawn_rate  ||= 60
+    state.zombie_spawn_countdown ||= random_spawn_countdown state.zombie_min_spawn_rate
+    state.zombies                ||= []
+    state.killed_zombies         ||= []
 
-1. Create an item of STATE named SPRITE_FRAME: state.sprite_frame =
-2. Set this SPRITE_FRAME to the PASSAGE OF TIME (tick_count),
-   DIVIDED EVENLY (idiv) into 4,
-   and then compute the REMAINDER (mod) of 6.
+    # Declares player as a new entity and sets its properties.
+    # The player begins the game in the center of the screen, not moving in any direction.
+    state.player ||= state.new_entity(:player, { x: 640,
+                                               y: 360,
+                                               attack_angle: 0,
+                                               dx: 0,
+                                               dy: 0 })
+  end
 
-   STATE   SPRITE_FRAME    PASSAGE OF      HOW LONG   HOW MANY
-     |          |             TIME         TO SHOW    IMAGES
-     |          |              |           AN IMAGE   TO FLIP THROUGH
-     |          |              |               |      |
-state.sprite_frame =     state.tick_count.idiv(4).mod(6)
-                                           |       |
-                                           |       +- REMAINDER OF DIVIDE
-                                    DIVIDE EVENLY
-                                    (NO DECIMALS)
+  # Outputs a gray background.
+  # Calls the methods needed to output the player, zombies, etc onto the screen.
+  def render
+    outputs.solids << [grid.rect, 100, 100, 100]
+    render_zombies
+    render_killed_zombies
+    render_player
+    render_flash
+  end
 
-With the information above, we can animate a SPRITE
-using STRING INTERPOLATION: \#{}
-which creates a unique SPRITE_PATH:
+  # Outputs the zombies on the screen and sets values for the sprites, such as the position, width, height, and animation.
+  def render_zombies
+    outputs.sprites << state.zombies.map do |z| # performs action on all zombies in the collection
+      z.sprite = [z.x, z.y, 4 * 3, 8 * 3, animation_sprite(z)].sprite # sets definition for sprite, calls animation_sprite method
+      z.sprite
+    end
+  end
 
-  state.sprite_path =  \"sprites/dragon_fly_\#{state.sprite_frame}.png\"
-  outputs.labels    << [910, 330, \"path: \#{state.sprite_path}\", 0, 255, 0]
-  outputs.sprites   << [910, 330, 370, 370, state.sprite_path]
+  # Outputs sprites of killed zombies, and displays a slash image to show that a zombie has been killed.
+  def render_killed_zombies
+    outputs.sprites << state.killed_zombies.map do |z| # performs action on all killed zombies in collection
+      z.sprite = [z.x,
+                  z.y,
+                  4 * 3,
+                  8 * 3,
+                  animation_sprite(z, z.death_at), # calls animation_sprite method
+                  0, # angle
+                  255 * z.death_at.ease(30, :flip)].sprite # transparency of a zombie changes when they die
+                  # change the value of 30 and see what happens when a zombie is killed
 
-Type the lines above (pressing ENTER after each line).
-"
-end
+      # Sets values to output the slash over the zombie's sprite when a zombie is killed.
+      # The slash is tilted 45 degrees from the angle of the player's attack.
+      # Change the 3 inside scale_rect to 30 and the slash will be HUGE! Scale_rect positions
+      # the slash over the killed zombie's sprite.
+      [z.sprite, [z.sprite.rect, 'sprites/slash.png', 45 + state.player.attack_angle_on_click, z.sprite.a].scale_rect(3, 0.5, 0.5)]
+    end
+  end
 
-def tick_reprint_on_error
-  return unless console.last_command_errored
-  puts $gtk.state.messages.last
-  puts "\nWhoops! Try again."
-  console.last_command_errored = false
-end
+  # Outputs the player sprite using the images in the sprites folder.
+  def render_player
+    state.player_sprite = [state.player.x,
+                           state.player.y,
+                          4 * 3,
+                          8 * 3, "sprites/player-#{animation_index(state.player.created_at_elapsed)}.png"] # string interpolation
+    outputs.sprites << state.player_sprite
 
-def tick_evals
-  state.evals ||= []
-  if console.last_command && (console.last_command.start_with?("outputs.") || console.last_command.start_with?("state."))
-    state.evals << console.last_command
-    console.last_command = nil
+    # Outputs a small red square that previews the angles that the player can attack in.
+    # It can be moved in a perfect circle around the player to show possible movements.
+    # Change the 60 in the parenthesis and see what happens to the movement of the red square.
+    outputs.solids <<  [state.player.x + state.player.attack_angle.vector_x(60),
+                        state.player.y + state.player.attack_angle.vector_y(60),
+                        3, 3, 255, 0, 0]
   end
 
-  state.evals.each do |l|
-    Kernel.eval l
-  end
-rescue Exception => e
-  state.evals = state.evals[0..-2]
-end
+  # Renders flash as a solid. The screen turns white for 10 frames when a zombie is killed.
+  def render_flash
+    return if state.flash_at.elapsed_time > 10 # return if more than 10 frames have passed since flash.
+    # Transparency gradually changes (or eases) during the 10 frames of flash.
+    outputs.primitives << [grid.rect, 255, 255, 255, 255 * state.flash_at.ease(10, :flip)].solid
+  end
 
-$tutorial_outputs ||= TutorialOutputs.new
+  # Calls all methods necessary for performing calculations.
+  def calc
+    calc_spawn_zombie
+    calc_move_zombies
+    calc_player
+    calc_kill_zombie
+  end
 
-def tick args
-  $gtk.log_level = :off
-  defaults
-  console.show
-  $tutorial_outputs.clear
-  $tutorial_outputs.solids  << [900, 37, 480, 700,   0,   0,   0, 255]
-  $tutorial_outputs.borders << [900, 37, 380, 683, 255, 255, 255]
-  tick_evals
-  $tutorial_outputs.tick
-  tick_intro
-  tick_hello_dragonruby
-  tick_reset_button
-  tick_explain_solid
-  tick_explain_solid_blue
-  tick_reprint_on_error
-  tick_explain_tick_count
-  tick_explain_mod
-  tick_explain_string_interpolation
-end
+  # Decreases the zombie spawn countdown by 1 if it has a value greater than 0.
+  def calc_spawn_zombie
+    if state.zombie_spawn_countdown > 0
+      state.zombie_spawn_countdown -= 1
+      return
+    end
 
-def console
-  $gtk.console
-end
+    # New zombies are created, positioned on the screen, and added to the zombies collection.
+    state.zombies << state.new_entity(:zombie) do |z| # each zombie is declared a new entity
+      if rand > 0.5
+        z.x = grid.rect.w.randomize(:ratio) # random x position on screen (within grid scope)
+        z.y = [-10, 730].sample # y position is set to either -10 or 730 (randomly chosen)
+        # the possible values exceed the screen's scope so zombies appear to be coming from far away
+      else
+        z.x = [-10, 1290].sample # x position is set to either -10 or 1290 (randomly chosen)
+        z.y = grid.rect.w.randomize(:ratio) # random y position on screen
+      end
+    end
 
-def queue_message message
-  $gtk.args.state.messages ||= []
-  return if $gtk.args.state.messages.include? message
-  $gtk.args.state.messages << message
-  last_three = [$gtk.console.log[-3], $gtk.console.log[-2], $gtk.console.log[-1]].reject_nil
-  $gtk.console.log.clear
-  puts seperator
-  $gtk.console.log += last_three
-  puts seperator
-  puts message
-  puts seperator
-end
+    # Calls random_spawn_countdown method (determines how fast new zombies appear)
+    state.zombie_spawn_countdown = random_spawn_countdown state.zombie_min_spawn_rate
+    state.zombie_min_spawn_rate -= 1
+    # set to either the current zombie_min_spawn_rate or 0, depending on which value is greater
+    state.zombie_min_spawn_rate  = state.zombie_min_spawn_rate.greater(0)
+  end
 
-def console_has? message
-  console.log.map(&:upcase).include? "#{message.upcase}\n"
-end
+  # Moves all zombies towards the center of the screen.
+  # All zombies that reach the center (640, 360) are rejected from the zombies collection and disappear.
+  def calc_move_zombies
+    state.zombies.each do |z| # for each zombie in the collection
+      z.y = z.y.towards(360, 0.1) # move the zombie towards the center (640, 360) at a rate of 0.1
+      z.x = z.x.towards(640, 0.1) # change 0.1 to 1.1 and see how much faster the zombies move to the center
+    end
+    state.zombies = state.zombies.reject { |z| z.y == 360 && z.x == 640 } # remove zombies that are in center
+  end
 
-def restart_tutorial
-  $tutorial_outputs.clear
-  $gtk.console.log.clear
-  $gtk.reset
-  puts "Starting the tutorial over!"
-end
+  # Calculates the position and movement of the player on the screen.
+  def calc_player
+    state.player.x += state.player.dx # changes x based on dx (change in x)
+    state.player.y += state.player.dy # changes y based on dy (change in y)
 
-def state
-  $gtk.args.state
-end
+    state.player.dx *= 0.9 # scales dx down
+    state.player.dy *= 0.9 # scales dy down
 
-def inputs
-  $gtk.args.inputs
-end
+    # Compares player's x to 1280 to find lesser value, then compares result to 0 to find greater value.
+    # This ensures that the player remains within the screen's scope.
+    state.player.x = state.player.x.lesser(1280).greater(0)
+    state.player.y = state.player.y.lesser(720).greater(0) # same with player's y
+  end
 
-def outputs
-  $tutorial_outputs
-end
+  # Finds all zombies that intersect with the player's sprite. These zombies are removed from the zombies collection
+  # and added to the killed_zombies collection since any zombie that intersects with the player is killed.
+  def calc_kill_zombie
 
-

-Learn Ruby Optional - Intermediate Ruby Primer - printing.txt
-# ./samples/00_learn_ruby_optional/00_intermediate_ruby_primer/app/01_printing.txt
-# ====================================================================================
-# Commenting Code
-# ====================================================================================
-#
-# Prefixing text with a pound sign (#) is how you comment code in Ruby. Example:
-#
-# I am commented code. And so are the lines above.
-#
-# I you want more than a quick primer on Ruby, check out https://poignant.guide/. It's
-# an entertaining read. Otherwise, go to the next txt file.
-#
-# Follow along by visiting:
-# https://s3.amazonaws.com/s3.dragonruby.org/dragonruby-gtk-intermediate.mp4
+    # Find all zombies that intersect with the player. They are considered killed.
+    killed_this_frame = state.zombies.find_all { |z| z.sprite.intersect_rect? state.player_sprite }
+    state.zombies = state.zombies - killed_this_frame # remove newly killed zombies from zombies collection
+    state.killed_zombies += killed_this_frame # add newly killed zombies to killed zombies
 
-# ====================================================================================
-#  Printing to the Console:
-# ====================================================================================
-#
-# Every time you save repl.rb file, DragonRuby runs the code within it. Copy this text
-# to repl.rb and save to see Hello World printed to the console.
+    if killed_this_frame.length > 0 # if atleast one zombie was killed in the frame
+      state.flash_at = state.tick_count # flash_at set to the frame when the zombie was killed
+    # Don't forget, the rendered flash lasts for 10 frames after the zombie is killed (look at render_flash method)
+    end
 
-repl do
-  puts '* RUBY PRIMER: Printing to the console using the ~puts~ function.'
-  puts '===='
-  puts '======'
-  puts '================================'
-  puts 'Hello World'
-  puts '================================'
-  puts '======'
-  puts '===='
-end
+    # Sets the tick_count (passage of time) as the value of the death_at variable for each killed zombie.
+    # Death_at stores the frame a zombie was killed.
+    killed_this_frame.each do |z|
+      z.death_at = state.tick_count
+    end
 
-
-Learn Ruby Optional - Intermediate Ruby Primer - strings.txt
-# ./samples/00_learn_ruby_optional/00_intermediate_ruby_primer/app/02_strings.txt
-# ====================================================================================
-#  Strings
-# ====================================================================================
-#
-# Here is how you work with strings in Ruby. Take the text
-# in this file and paste it into repl.rb and save:
+    # Zombies are rejected from the killed_zombies collection depending on when they were killed.
+    # They are rejected if more than 30 frames have passed since their death.
+    state.killed_zombies = state.killed_zombies.reject { |z| state.tick_count - z.death_at > 30 }
+  end
 
-repl do
-  puts '* RUBY PRIMER: strings'
-  message = "Hello World"
-  puts "The value of message is: " + message
-  puts "Any value can be interpolated within a string using \#{}."
-  puts "Interpolated message: #{message}."
-  puts 'This #{message} is not interpolated because the string uses single quotes.'
-end
+  # Uses input from the user to move the player around the screen.
+  def input
 
-
-Learn Ruby Optional - Intermediate Ruby Primer - numbers.txt
-# ./samples/00_learn_ruby_optional/00_intermediate_ruby_primer/app/03_numbers.txt
-# ====================================================================================
-#  Numerics
-# ====================================================================================
-#
-# Here is how you work with numbers in Ruby. Take the text
-# in this file and paste it into repl.rb and save:
+    # If the "a" key or left key is pressed, the x position of the player decreases.
+    # Otherwise, if the "d" key or right key is pressed, the x position of the player increases.
+    if inputs.keyboard.key_held.a || inputs.keyboard.key_held.left
+      state.player.x -= 5
+    elsif inputs.keyboard.key_held.d || inputs.keyboard.key_held.right
+      state.player.x += 5
+    end
 
-repl do
-  puts '* RUBY PRIMER: Fixnum and Floats'
-  a = 10
-  puts "The value of a is: #{a}"
-  puts "a + 1 is: #{a + 1}"
-  puts "a / 3 is: #{a / 3}"
-  puts ''
+    # If the "w" or up key is pressed, the y position of the player increases.
+    # Otherwise, if the "s" or down key is pressed, the y position of the player decreases.
+    if inputs.keyboard.key_held.w || inputs.keyboard.key_held.up
+      state.player.y += 5
+    elsif inputs.keyboard.key_held.s || inputs.keyboard.key_held.down
+      state.player.y -= 5
+    end
 
-  b = 10.12
-  puts "The value of b is: #{b}"
-  puts "b + 1 is: #{b + 1}"
-  puts "b as an integer is: #{b.to_i}"
-  puts ''
-end
+    # Sets the attack angle so the player can move and attack in the precise direction it wants to go.
+    # If the mouse is moved, the attack angle is changed (based on the player's position and mouse position).
+    # Attack angle also contributes to the position of red square.
+    if inputs.mouse.moved
+      state.player.attack_angle = inputs.mouse.position.angle_from [state.player.x, state.player.y]
+    end
 
-
-Learn Ruby Optional - Intermediate Ruby Primer - booleans.txt
-# ./samples/00_learn_ruby_optional/00_intermediate_ruby_primer/app/04_booleans.txt
-# ====================================================================================
-#  Booleans
-# ====================================================================================
-#
-# Here is how you work with numbers in Ruby. Take the text
-# in this file and paste it into repl.rb and save:
+    if inputs.mouse.click && state.player.dx < 0.5 && state.player.dy < 0.5
+      state.player.attack_angle_on_click = inputs.mouse.position.angle_from [state.player.x, state.player.y]
+      state.player.attack_angle = state.player.attack_angle_on_click # player's attack angle is set
+      state.player.dx = state.player.attack_angle.vector_x(25) # change in player's position
+      state.player.dy = state.player.attack_angle.vector_y(25)
+    end
+  end
 
-repl do
-  puts '* RUBY PRIMER: TrueClass, FalseClass, NilClass (truthy / falsey values)'
-  puts "Anything that *isn't* false or nil is true."
+  # Sets the zombie spawn's countdown to a random number.
+  # How fast zombies appear (change the 60 to 6 and too many zombies will appear at once!)
+  def random_spawn_countdown minimum
+    10.randomize(:ratio, :sign).to_i + 60
+  end
 
-  c = 30
-  puts "The value of c is #{c}."
+  # Helps to iterate through the images in the sprites folder by setting the animation index.
+  # 3 frames is how long to show an image, and 6 is how many images to flip through.
+  def animation_index at
+    at.idiv(3).mod(6)
+  end
 
-  if c
-    puts "This if statement ran because c is truthy."
+  # Animates the zombies by using the animation index to go through the images in the sprites folder.
+  def animation_sprite zombie, at = nil
+    at ||= zombie.created_at_elapsed # how long it is has been since a zombie was created
+    index = animation_index at
+    "sprites/zombie-#{index}.png" # string interpolation to iterate through images
   end
+end
 
-  d = false
-  puts "The value if d is #{d}. The type for d is #{d.class}."
+$protect_the_puppies_from_the_zombies = ProtectThePuppiesFromTheZombies.new
+
+def tick args
+  $protect_the_puppies_from_the_zombies.grid    = args.grid
+  $protect_the_puppies_from_the_zombies.inputs  = args.inputs
+  $protect_the_puppies_from_the_zombies.state    = args.state
+  $protect_the_puppies_from_the_zombies.outputs = args.outputs
+  $protect_the_puppies_from_the_zombies.tick
+  tick_instructions args, "How to get the mouse position and translate it to an x, y position using .vector_x and .vector_y. CLICK to play."
+end
 
-  if !d
-    puts "This if statement ran because d is falsey, using the not operator (!)."
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
   end
 
-  e = nil
-  puts "Nil is also considered falsey. The value of e is: #{e} (a blank string when printed). Which is of type #{e.class}."
-
-  if !e
-    puts "This if statement ran because e is nil and the if statement applied the NOT operator. !e yields a type of #{(!e).class}."
-  end
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
 end
 
-
-Learn Ruby Optional - Intermediate Ruby Primer - conditionals.txt
-# ./samples/00_learn_ruby_optional/00_intermediate_ruby_primer/app/05_conditionals.txt
-# ====================================================================================
-#  Conditionals
-# ====================================================================================
-#
-# Here is how you create conditionals in Ruby. Take the text
-# in this file and paste it into repl.rb and save:
+
+Mouse - Mouse Move Paint App - main.rb
+# ./samples/05_mouse/03_mouse_move_paint_app/app/main.rb
+=begin
 
-repl do
-  puts "* RUBY PRIMER: Conditionals"
-end
+ APIs listing that haven't been encountered in previous sample apps:
 
-# ====================================================================================
-#  if
-# ====================================================================================
+ - Floor: Method that returns an integer number smaller than or equal to the original with no decimal.
 
-repl do
-  puts "** INFO: if statement"
-  i_am_one = 1
-  if i_am_one
-    puts "This was printed because i_am_one is truthy."
-  end
-end
+   For example, if we have a variable, a = 13.7, and we called floor on it, it would look like this...
+   puts a.floor()
+   which would print out 13.
+   (There is also a ceil method, which returns an integer number greater than or equal to the original
+   with no decimal. If we had called ceil on the variable a, the result would have been 14.)
 
-# ====================================================================================
-#  if/else
-# ====================================================================================
+ Reminders:
 
-repl do
-  puts "** INFO: if/else statement"
-  i_am_false = false
-  if i_am_false
-    puts "This will NOT get printed because i_am_false is false."
-  else
-    puts "This was printed because i_am_false is false."
-  end
-end
+ - Hashes: Collection of unique keys and their corresponding values. The value can be found
+   using their keys.
 
+   For example, if we have a "numbers" hash that stores numbers in English as the
+   key and numbers in Spanish as the value, we'd have a hash that looks like this...
+   numbers = { "one" => "uno", "two" => "dos", "three" => "tres" }
+   and on it goes.
 
-# ====================================================================================
-#  if/elsif/else
-# ====================================================================================
+   Now if we wanted to find the corresponding value of the "one" key, we could say
+   puts numbers["one"]
+   which would print "uno" to the console.
 
-repl do
-  puts "** INFO: if/elsif/else statement"
-  i_am_false = false
-  i_am_true  = true
-  if i_am_false
-    puts "This will NOT get printed because i_am_false is false."
-  elsif i_am_true
-    puts "This was printed because i_am_true is true."
-  else
-    puts "This will NOT get printed i_am_true was true."
-  end
-end
+ - args.state.new_entity: Used when we want to create a new object, like a sprite or button.
+   In this sample app, new_entity is used to create a new button that clears the grid.
+   (Remember, you can use state to define ANY property and it will be retained across frames.)
 
-# ====================================================================================
-#  case
-# ====================================================================================
+ - args.inputs.mouse.click.point.(x|y): The x and y location of the mouse.
 
-repl do
-  puts "** INFO case statement"
-  i_am_one = 1 # change this value to see different results
+ - args.inputs.mouse.click.point.created_at: The frame the mouse click occurred in.
 
-  case i_am_one
-  when 10
-    puts "the value of i_am_one is 10"
-  when 9
-    puts "the value of i_am_one is 9"
-  when 5
-    puts "the value of i_am_one is 5"
-  when 1
-    puts "the value of i_am_one is 1"
-  else
-    puts "Value wasn't cased."
-  end
-end
+ - args.outputs.labels: An array. The values in the array generate a label.
+   The parameters are [X, Y, TEXT, SIZE, ALIGN, RED, GREEN, BLUE, ALPHA, FONT STYLE]
+   For more information about labels, go to mygame/documentation/02-labels.md.
 
-# ====================================================================================
-#  comparison operators
-# ====================================================================================
+ - ARRAY#inside_rect?: Returns true or false depending on if the point is inside the rect.
 
-repl do
-  puts "** INFO: Different types of comparisons"
-  if 4 == 4
-    puts "4 equals 4 (==)"
-  end
+=end
 
-  if 4 != 3
-    puts "4 does not equal 3 (!=)"
-  end
+# This sample app shows an empty grid that the user can paint on.
+# To paint, the user must keep their mouse presssed and drag it around the grid.
+# The "clear" button allows users to clear the grid so they can start over.
 
-  if 3 < 4
-    puts "3 is less than 4 (<)"
-  end
+class PaintApp
+  attr_accessor :inputs, :state, :outputs, :grid, :args
 
-  if 4 > 3
-    puts "4 is greater than 3 (>)"
+  # Runs methods necessary for the game to function properly.
+  def tick
+    print_title
+    add_grid
+    check_click
+    draw_buttons
   end
-end
 
-# ====================================================================================
-#  and/or conditionals
-# ====================================================================================
+  # Prints the title onto the screen by using a label.
+  # Also separates the title from the grid with a line as a horizontal separator.
+  def print_title
+    args.outputs.labels << [ 640, 700, 'Paint!', 0, 1 ]
+    outputs.lines << horizontal_separator(660, 0, 1280)
+  end
 
-repl do
-  puts "** INFO: AND, OR operator (&&, ||)"
-  if (4 > 3) || (3 < 4) || false
-    puts "print this if 4 is greater than 3 OR 3 is less than 4 OR false is true (||)"
+  # Sets the starting position, ending position, and color for the horizontal separator.
+  # The starting and ending positions have the same y values.
+  def horizontal_separator y, x, x2
+    [x, y, x2, y, 150, 150, 150]
   end
 
-  if (4 > 3) && (3 < 4)
-    puts "print this if 4 is greater than 3 AND 3 is less than 4 (&&)"
+  # Sets the starting position, ending position, and color for the vertical separator.
+  # The starting and ending positions have the same x values.
+  def vertical_separator x, y, y2
+    [x, y, x, y2, 150, 150, 150]
   end
-end
 
-

-Learn Ruby Optional - Intermediate Ruby Primer - looping.txt
-# ./samples/00_learn_ruby_optional/00_intermediate_ruby_primer/app/06_looping.txt
-# ====================================================================================
-#  Looping
-# ====================================================================================
-#
-# Looping looks a whole lot different than other languages.
-# But it's pretty awesome when you get used to it.
+  # Outputs a border and a grid containing empty squares onto the screen.
+  def add_grid
 
-repl do
-  puts "* RUBY PRIMER: Loops"
-end
+    # Sets the x, y, height, and width of the grid.
+    # There are 31 horizontal lines and 31 vertical lines in the grid.
+    # Feel free to count them yourself before continuing!
+    x, y, h, w = 640 - 500/2, 640 - 500, 500, 500 # calculations done so the grid appears in screen's center
+    lines_h = 31
+    lines_v = 31
 
-# ====================================================================================
-#  times
-# ====================================================================================
+    # Sets values for the grid's border, grid lines, and filled squares.
+    # The filled_squares variable is initially set to an empty array.
+    state.grid_border ||= [ x, y, h, w ] # definition of grid's outer border
+    state.grid_lines ||= draw_grid(x, y, h, w, lines_h, lines_v) # calls draw_grid method
+    state.filled_squares ||= [] # there are no filled squares until the user fills them in
 
-repl do
-  puts "** INFO: ~Numeric#times~ (for loop)"
-  3.times do |i|
-    puts i
+    # Outputs the grid lines, border, and filled squares onto the screen.
+    outputs.lines.concat state.grid_lines
+    outputs.borders << state.grid_border
+    outputs.solids << state.filled_squares
   end
-end
 
-# ====================================================================================
-#  foreach
-# ====================================================================================
+  # Draws the grid by adding in vertical and horizontal separators.
+  def draw_grid x, y, h, w, lines_h, lines_v
 
-repl do
-  puts "** INFO: ~Array#each~ (for each loop)"
-  array = ["a", "b", "c", "d"]
-  array.each do |char|
-    puts char
-  end
+    # The grid starts off empty.
+    grid = []
 
-  puts "** INFO: ~Array#each_with_index~ (for each loop)"
-  array = ["a", "b", "c", "d"]
-  array.each do |char, i|
-    puts "index #{i}: #{char}"
-  end
-end
+    # Calculates the placement and adds horizontal lines or separators into the grid.
+    curr_y = y # start at the bottom of the box
+    dist_y = h / (lines_h + 1) # finds distance to place horizontal lines evenly throughout 500 height of grid
+    lines_h.times do
+      curr_y += dist_y # increment curr_y by the distance between the horizontal lines
+      grid << horizontal_separator(curr_y, x, x + w - 1) # add a separator into the grid
+    end
 
-# ====================================================================================
-#  ranges
-# ====================================================================================
+    # Calculates the placement and adds vertical lines or separators into the grid.
+    curr_x = x # now start at the left of the box
+    dist_x = w / (lines_v + 1) # finds distance to place vertical lines evenly throughout 500 width of grid
+    lines_v.times do
+      curr_x += dist_x # increment curr_x by the distance between the vertical lines
+      grid << vertical_separator(curr_x, y + 1, y  + h) # add separator
+    end
 
-repl do
-  puts "** INFO: range block exclusive (three dots)"
-  (0...3).each do |i|
-    puts i
-  end
+    # paint_grid uses a hash to assign values to keys.
+    state.paint_grid ||= {"x" => x, "y" => y, "h" => h, "w" => w, "lines_h" => lines_h,
+                          "lines_v" => lines_v, "dist_x" => dist_x,
+                          "dist_y" => dist_y }
 
-  puts "** INFO: range block inclusive (two dots)"
-  (0..3).each do |i|
-    puts i
+    return grid
   end
-end
 
-
-Learn Ruby Optional - Intermediate Ruby Primer - functions.txt
-# ./samples/00_learn_ruby_optional/00_intermediate_ruby_primer/app/07_functions.txt
-# ====================================================================================
-# Functions
-# ====================================================================================
+  # Checks if the user is keeping the mouse pressed down and sets the mouse_hold variable accordingly using boolean values.
+  # If the mouse is up, the user cannot drag the mouse.
+  def check_click
+    if inputs.mouse.down #is mouse up or down?
+      state.mouse_held = true # mouse is being held down
+    elsif inputs.mouse.up # if mouse is up
+    state.mouse_held = false # mouse is not being held down or dragged
+      state.mouse_dragging = false
+    end
+
+    if state.mouse_held &&    # mouse needs to be down
+      !inputs.mouse.click &&     # must not be first click
+      ((inputs.mouse.previous_click.point.x - inputs.mouse.position.x).abs > 15) # Need to move 15 pixels before "drag"
+      state.mouse_dragging = true
+    end
 
-# The last statement of a function is implictly returned. Parenthesis for functions
-# are optional as long as the statement can be envaluated disambiguously.
+    # If the user clicks their mouse inside the grid, the search_lines method is called with a click input type.
+    if ((inputs.mouse.click) && (inputs.mouse.click.point.inside_rect? state.grid_border))
+      search_lines(inputs.mouse.click.point, :click)
 
-repl do
-  puts "* RUBY PRIMER: Functions"
-end
+    # If the user drags their mouse inside the grid, the search_lines method is called with a drag input type.
+    elsif ((state.mouse_dragging) && (inputs.mouse.position.inside_rect? state.grid_border))
+      search_lines(inputs.mouse.position, :drag)
+    end
+  end
 
-# ====================================================================================
-# Functions single parameter
-# ====================================================================================
+  # Sets the definition of a grid box and handles user input to fill in or clear grid boxes.
+  def search_lines (point, input_type)
+    point.x -= state.paint_grid["x"] # subtracts the value assigned to the "x" key in the paint_grid hash
+    point.y -= state.paint_grid["y"] # subtracts the value assigned to the "y" key in the paint_grid hash
 
-repl do
-  puts "* INFO: Function with one parameter"
+    # Remove code following the .floor and see what happens when you try to fill in grid squares
+    point.x = (point.x / state.paint_grid["dist_x"]).floor * state.paint_grid["dist_x"]
+    point.y = (point.y / state.paint_grid["dist_y"]).floor * state.paint_grid["dist_y"]
 
-  # function definition
-  def add_one_to n
-    n + 1
-  end
+    point.x += state.paint_grid["x"]
+    point.y += state.paint_grid["y"]
 
-  # Parenthesis are optional in Ruby as long as the
-  # parsing is disambiguous. Here are a couple of variations.
-  # Generally speaking, don't put parenthesis is you don't have to.
+    # Sets definition of a grid box, meaning its x, y, width, and height.
+    # Floor is called on the point.x and point.y variables.
+    # Ceil method is called on values of the distance hash keys, setting the width and height of a box.
+    grid_box = [ point.x.floor, point.y.floor, state.paint_grid["dist_x"].ceil, state.paint_grid["dist_y"].ceil ]
 
-  # Conventional Usage of Parenthesis.
-  puts add_one_to(3)
+    if input_type == :click # if user clicks their mouse
+      if state.filled_squares.include? grid_box # if grid box is already filled in
+        state.filled_squares.delete grid_box # box is cleared and removed from filled_squares
+      else
+        state.filled_squares << grid_box # otherwise, box is filled in and added to filled_squares
+      end
+    elsif input_type == :drag # if user drags mouse
+      unless state.filled_squares.include? grid_box # unless the grid box dragged over is already filled in
+        state.filled_squares << grid_box # the box is filled in and added to filled_squares
+      end
+    end
+  end
 
-  # DragonRuby's recommended use of parenthesis (inner function has parenthesis).
-  puts (add_one_to 3)
+  # Creates and outputs a "Clear" button on the screen using a label and a border.
+  # If the button is clicked, the filled squares are cleared, making the filled_squares collection empty.
+  def draw_buttons
+    x, y, w, h = 390, 50, 240, 50
+    state.clear_button        ||= state.new_entity(:button_with_fade)
 
-  # Full parens.
-  puts(add_one_to(3))
+    # The x and y positions are set to display the label in the center of the button.
+    # Try changing the first two parameters to simply x, y and see what happens to the text placement!
+    state.clear_button.label  ||= [x + w.half, y + h.half + 10, "Clear", 0, 1] # placed in center of border
+    state.clear_button.border ||= [x, y, w, h]
 
-  # Outer function has parenthesis
-  puts(add_one_to 3)
-end
+    # If the mouse is clicked inside the borders of the clear button,
+    # the filled_squares collection is emptied and the squares are cleared.
+    if inputs.mouse.click && inputs.mouse.click.point.inside_rect?(state.clear_button.border)
+      state.clear_button.clicked_at = inputs.mouse.click.created_at # time (frame) the click occurred
+      state.filled_squares.clear
+      inputs.mouse.previous_click = nil
+    end
 
-# ====================================================================================
-# Functions with default parameter values
-# ====================================================================================
+    outputs.labels << state.clear_button.label
+    outputs.borders << state.clear_button.border
 
-repl do
-  puts "* INFO: Function with default value"
-  def function_with_default_value v = 10
-    v * 10
+    # When the clear button is clicked, the color of the button changes
+    # and the transparency changes, as well. If you change the time from
+    # 0.25.seconds to 1.25.seconds or more, the change will last longer.
+    if state.clear_button.clicked_at
+      outputs.solids << [x, y, w, h, 0, 180, 80, 255 * state.clear_button.clicked_at.ease(0.25.seconds, :flip)]
+    end
   end
-
-  puts "Passing the argument three yields: #{function_with_default_value 3}"
-  puts "Passing no argument yields: #{function_with_default_value}"
 end
 
-# ====================================================================================
-# Nil default parameter value and ||= operator.
-# ====================================================================================
-
-repl do
-  puts "* INFO: Using the OR EQUAL operator (||=)"
-  def function_with_nil_default_with_local a = nil
-    result   = a
-    result ||= "DEFAULT_VALUE_OF_A_IS_NIL_OR_FALSE"
-    "value is #{result}."
-  end
+$paint_app = PaintApp.new
 
-  puts "Passing 'hi' as the argument yields: #{function_with_nil_default_with_local 'hi'}"
-  puts "Passing nil: #{function_with_nil_default_with_local}"
+def tick args
+  $paint_app.inputs = args.inputs
+  $paint_app.state = args.state
+  $paint_app.grid = args.grid
+  $paint_app.args = args
+  $paint_app.outputs = args.outputs
+  $paint_app.tick
+  tick_instructions args, "How to create a simple paint app. CLICK and HOLD to draw."
 end
 
-
-Learn Ruby Optional - Intermediate Ruby Primer - arrays.txt
-# ./samples/00_learn_ruby_optional/00_intermediate_ruby_primer/app/08_arrays.txt
-# ====================================================================================
-# Arrays
-# ====================================================================================
-
-# Arrays are incredibly powerful in Ruby. Learn to use them well.
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
+  end
 
-repl do
-  puts "* RUBY PRIMER: ARRAYS"
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
 end
 
-# ====================================================================================
-# Enumerable ranges and .to_a
-# ====================================================================================
+
+Mouse - Coordinate Systems - main.rb
+# ./samples/05_mouse/04_coordinate_systems/app/main.rb
+=begin
 
-repl do
-  puts "** INFO: Create an array with the numbers 1 to 10."
-  one_to_ten = (1..10).to_a
-  puts one_to_ten
-end
+ APIs listing that haven't been encountered in previous sample apps:
 
-# ====================================================================================
-# Finding elements
-# ====================================================================================
+ - args.inputs.mouse.click.position: Coordinates of the mouse's position on the screen.
+   Unlike args.inputs.mouse.click.point, the mouse does not need to be pressed down for
+   position to know the mouse's coordinates.
+   For more information about the mouse, go to mygame/documentation/07-mouse.md.
 
-repl do
-  puts "** INFO: Finding elements in an array using ~Array#find_all~."
-  puts "Create a new array that only contains even numbers from the previous array."
+ Reminders:
 
-  one_to_ten = (1..10).to_a
-  evens = one_to_ten.find_all do |number|
-    number % 2 == 0
-  end
+ - args.inputs.mouse.click: This property will be set if the mouse was clicked.
 
-  puts evens
-end
+ - args.inputs.mouse.click.point.(x|y): The x and y location of the mouse.
 
-# ====================================================================================
-# Rejecting elements
-# ====================================================================================
+ - String interpolation: Uses #{} syntax; everything between the #{ and the } is evaluated
+   as Ruby code, and the placeholder is replaced with its corresponding value or result.
 
-repl do
-  puts "** INFO: Removing elements in an array using ~Array#reject~."
-  puts "Create a new array that rejects odd numbers."
+   In this sample app, string interpolation is used to show the current position of the mouse
+   in a label.
 
-  one_to_ten = (1..10).to_a
-  also_even = one_to_ten.reject do |number|
-    number % 2 != 0
-  end
+ - args.outputs.labels: An array that generates a label.
+   The parameters are [X, Y, TEXT, SIZE, ALIGN, RED, GREEN, BLUE, ALPHA, FONT STYLE]
+   For more information about labels, go to mygame/documentation/02-labels.md.
 
-  puts also_even
-end
+ - args.outputs.solids: An array that generates a solid.
+   The parameters are [X, Y, WIDTH, HEIGHT, RED, GREEN, BLUE, ALPHA]
+   For more information about solids, go to mygame/documentation/03-solids-and-borders.md.
 
-# ====================================================================================
-# Array transform using the map function.
-# ====================================================================================
+ - args.outputs.lines: An array that generates a line.
+   The parameters are [X, Y, X2, Y2, RED, GREEN, BLUE, ALPHA]
+   For more information about lines, go to mygame/documentation/04-lines.md.
 
-repl do
-  puts "** INFO: Creating new derived values from an array using ~Array#map~."
-  puts "Create an array that doubles every number."
+=end
 
-  one_to_ten = (1..10).to_a
-  doubled = one_to_ten.map do |number|
-    number * 2
-  end
+# This sample app shows a coordinate system or grid. The user can move their mouse around the screen and the
+# coordinates of their position on the screen will be displayed. Users can choose to view one quadrant or
+# four quadrants by pressing the button.
 
-  puts doubled
-end
+def tick args
 
-# ====================================================================================
-# Combining array functions.
-# ====================================================================================
+  # The addition and subtraction in the first two parameters of the label and solid
+  # ensure that the outputs don't overlap each other. Try removing them and see what happens.
+  pos = args.inputs.mouse.position # stores coordinates of mouse's position
+  args.outputs.labels << [pos.x + 10, pos.y + 10, "#{pos}"] # outputs label of coordinates
+  args.outputs.solids << [pos.x -  2, pos.y - 2, 5, 5] # outputs small blackk box placed where mouse is hovering
 
-repl do
-  puts "** INFO: Combining ~Array#find_all~ along with ~Array#map~."
-  puts "Create an array that selects only odd numbers and then multiply those by 10."
+  button = [0, 0, 370, 50] # sets definition of toggle button
+  args.outputs.borders << button # outputs button as border (not filled in)
+  args.outputs.labels << [10, 35, "click here toggle coordinate system"] # label of button
+  args.outputs.lines << [    0, -720,    0, 720] # vertical line dividing quadrants
+  args.outputs.lines << [-1280,    0, 1280,   0] # horizontal line dividing quadrants
 
-  one_to_ten = (1..10).to_a
-  odd_doubled = one_to_ten.find_all do |number|
-    number % 2 != 0
-  end.map do |odd_number|
-    odd_number * 10
+  if args.inputs.mouse.click # if the user clicks the mouse
+    pos = args.inputs.mouse.click.point # pos's value is point where user clicked (coordinates)
+    if pos.inside_rect? button # if the click occurred inside the button
+      if args.grid.name == :bottom_left # if the grid shows bottom left as origin
+        args.grid.origin_center! # origin will be shown in center
+      else
+        args.grid.origin_bottom_left! # otherwise, the view will change to show bottom left as origin
+      end
+    end
   end
 
-  puts odd_doubled
+  tick_instructions args, "Sample app shows the two supported coordinate systems in Game Toolkit."
 end
 
-# ====================================================================================
-# Product function.
-# ====================================================================================
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
+  end
 
-repl do
-  puts "** INFO: Create all combinations of array values using ~Array#product~."
-  puts "All two-item pairs of numbers 1 to 10."
-  one_to_ten = (1..10).to_a
-  all_combinations = one_to_ten.product(one_to_ten)
-  puts all_combinations
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
 end
 
-# ====================================================================================
-# Uniq and sort function.
-# ====================================================================================
+
+Save Load - Save Load Game - main.rb
+# ./samples/06_save_load/01_save_load_game/app/main.rb
+=begin
 
-repl do
-  puts "** INFO: Providing uniq values using ~Array#uniq~ and ~Array#sort~."
-  puts "All uniq combinations of numbers regardless of order."
-  puts "For example: [1, 2] is the same as [2, 1]."
-  one_to_ten = (1..10).to_a
-  uniq_combinations =
-    one_to_ten.product(one_to_ten)
-              .map do |unsorted_number|
-                unsorted_number.sort
-              end.uniq
-  puts uniq_combinations
-end
+ APIs listing that haven't been encountered in previous sample apps:
 
-# ====================================================================================
-# Example of an advanced array transform.
-# ====================================================================================
+ - Symbol (:): Ruby object with a name and an internal ID. Symbols are useful
+   because with a given symbol name, you can refer to the same object throughout
+   a Ruby program.
 
-repl do
-  puts "** INFO: Advanced chaining. Combining ~Array's ~map~, ~find_all~, ~sort~, and ~sort_by~."
-  puts "All unique Pythagorean Triples between 1 and 100 sorted by area of the triangle."
+   In this sample app, we're using symbols for our buttons. We have buttons that
+   light fires, save, load, etc. Each of these buttons has a distinct symbol like
+   :light_fire, :save_game, :load_game, etc.
 
-  one_to_hundred = (1..100).to_a
+ - to_sym: Returns the symbol corresponding to the given string; creates the symbol
+   if it does not already exist.
+   For example,
+   'car'.to_sym
+   would return the symbol :car.
 
-  triples =
-    one_to_hundred.product(one_to_hundred).map do |width, height|
-                [width, height, Math.sqrt(width ** 2 + height ** 2)]
-              end.find_all do |_, _, hypotenuse|
-                hypotenuse.to_i == hypotenuse
-              end.map do |triangle|
-                triangle.map(&:to_i)
-              end.uniq do |triangle|
-                triangle.sort
-              end.map do |width, height, hypotenuse|
-                [width, height, hypotenuse, (width * height) / 2]
-              end.sort_by do |_, _, _, area|
-                area
-              end
+ - last: Returns the last element of an array.
 
-  triples.each do |width, height, hypotenuse, _|
-    puts "(#{width}, #{height}, #{hypotenuse})"
-  end
-end
+ Reminders:
 
-# ====================================================================================
-# Example of an sorting.
-# ====================================================================================
+ - num1.lesser(num2): finds the lower value of the given options.
+   For example, in the statement
+   a = 4.lesser(3)
+   3 has a lower value than 4, which means that the value of a would be set to 3,
+   but if the statement had been
+   a = 4.lesser(5)
+   4 has a lower value than 5, which means that the value of a would be set to 4.
 
-repl do
-  puts "** INFO: Implementing a custom sort function that operates on the ~Hash~ datatype."
+ - num1.fdiv(num2): returns the float division (will have a decimal) of the two given numbers.
+   For example, 5.fdiv(2) = 2.5 and 5.fdiv(5) = 1.0
 
-  things_to_sort = [
-    { type: :background, order: 1 },
-    { type: :foreground, order: 1 },
-    { type: :foreground, order: 2 }
-  ]
-  puts "*** Original array."
-  puts things_to_sort
+ - String interpolation: uses #{} syntax; everything between the #{ and the } is evaluated
+   as Ruby code, and the placeholder is replaced with its corresponding value or result.
 
-  puts "*** Simple sort using key."
-  # For a simple sort, you can use sort_by
-  results = things_to_sort.sort_by do |hash|
-    hash[:order]
-  end
+ - args.outputs.labels: An array. Values generate a label.
+   Parameters are [X, Y, TEXT, SIZE, ALIGN, RED, GREEN, BLUE, ALPHA, FONT STYLE]
+   For more information, go to mygame/documentation/02-labels.md.
 
-  puts results
+ - ARRAY#inside_rect?: An array with at least two values is considered a point. An array
+   with at least four values is considered a rect. The inside_rect? function returns true
+   or false depending on if the point is inside the rect.
 
-  puts "*** Custom sort."
-  puts "**** Sorting process."
-  # for a more complicated sort, you can provide a block that returns
-  # -1, 0, 1 for a left and right operand
-  results = things_to_sort.sort do |l, r|
-    sort_result = 0
-    puts "here is l: #{l}"
-    puts "here is r: #{r || "nil"}"
-    # if either value is nil/false return 0
-    if !l || !r
-      sort_result = 0
-    # if the type of "left" is background and the
-    # type of "right" is foreground, then return
-    # -1 (which means "left" is less than "right"
-    elsif l[:type] == :background && r[:type] == :foreground
-      sort_result = -1
-    # if the type of "left" is foreground and the
-    # type of "right" is background, then return
-    #  1 (which means "left" is greater than "right"
-    elsif l[:type] == :foreground && r[:type] == :background
-      sort_result = 1
-    # if "left" and "right"'s type are the same, then
-    # use the order as the tie breaker
-    elsif l[:order] < r[:order]
-      sort_result = -1
-    elsif l[:order] > r[:order]
-      sort_result = 1
-    # returning 0 means both values are equal
-    else
-      sort_result = 0
-    end
-    sort_result
-  end.to_a
+=end
 
-  puts "**** Sort result."
-  puts results
-end
+# This code allows users to perform different tasks, such as saving and loading the game.
+# Users also have options to reset the game and light a fire.
 
-# ====================================================================================
-# Api documention for Array that is worth commiting to memory because arrays are so
-# awesome in Ruby: https://docs.ruby-lang.org/en/2.0.0/Array.html
-# ====================================================================================
+class TextedBasedGame
 
-

-Learn Ruby Optional - Intermediate Ruby Primer - main.rb
-# ./samples/00_learn_ruby_optional/00_intermediate_ruby_primer/app/main.rb
-def tick args
-  args.outputs.labels << [640, 380, "Open repl.rb in the text editor of your choice and follow the document.", 0, 1]
-end
+  # Contains methods needed for game to run properly.
+  # Increments tick count by 1 each time it runs (60 times in a single second)
+  def tick
+    default
+    show_intro
+    state.engine_tick_count += 1
+    tick_fire
+  end
 
-
-Rendering Basics - Labels - main.rb
-# ./samples/01_rendering_basics/01_labels/app/main.rb
-=begin
+  # Sets default values.
+  # The ||= ensures that a variable's value is only set to the value following the = sign
+  # if the value has not already been set before. Intialization happens only in the first frame.
+  def default
+    state.engine_tick_count ||= 0
+    state.active_module     ||= :room
+    state.fire_progress     ||= 0
+    state.fire_ready_in     ||= 10
+    state.previous_fire     ||= :dead
+    state.fire              ||= :dead
+  end
 
-APIs listing that haven't been encountered in a previous sample apps:
+  def show_intro
+    return unless state.engine_tick_count == 0 # return unless the game just started
+    set_story_line "awake." # calls set_story_line method, sets to "awake"
+  end
 
-- args.outputs.labels: An array. Values in this array generate labels
-  the screen.
-- args.grid.(left|right|top|bottom): Pixel value for the boundaries of the virtual
-  720 p screen (Dragon Ruby Game Toolkits's virtual resolution is always 1280x720).
-- Numeric#shift_(left|right|up|down): Shifts the Numeric in the correct direction
-  by adding or subracting.
+  # Sets story line.
+  def set_story_line story_line
+    state.story_line    = story_line # story line set to value of parameter
+    state.active_module = :alert # active module set to alert
+  end
 
-=end
+  # Clears story line.
+  def clear_storyline
+    state.active_module = :none # active module set to none
+    state.story_line = nil # story line is cleared, set to nil (or empty)
+  end
 
-# Labels are used to represent text elements in DragonRuby
+  # Determines fire progress (how close the fire is to being ready to light).
+  def tick_fire
+    return if state.active_module == :alert # return if active module is alert
+    state.fire_progress += 1 # increment fire progress
+    # fire_ready_in is 10. The fire_progress is either the current value or 10, whichever has a lower value.
+    state.fire_progress = state.fire_progress.lesser(state.fire_ready_in)
+  end
 
-# An example of creating a label is:
-# args.outputs.labels << [320, 640, "Example", 3, 1, 255, 0, 0, 200, manaspace.ttf]
+  # Sets the value of fire (whether it is dead or roaring), and the story line
+  def light_fire
+    return unless fire_ready? # returns unless the fire is ready to be lit
+    state.fire = :roaring # fire is lit, set to roaring
+    state.fire_progress = 0 # the fire progress returns to 0, since the fire has been lit
+    if state.fire != state.previous_fire
+      set_story_line "the fire is #{state.fire}." # the story line is set using string interpolation
+      state.previous_fire = state.fire
+    end
+  end
 
-# The code above does the following:
-# 1. GET the place where labels go: args.outputs.labels
-# 2. Request a new LABEL be ADDED: <<
-# 3. The DEFINITION of a SOLID is the ARRAY:
-#     [320, 640, "Example", 3,     1,   255,   0,    0,    200,  manaspace.ttf]
-#     [ X ,  Y,    TEXT,   SIZE, ALIGN, RED, GREEN, BLUE, ALPHA, FONT STYLE]
+  # Checks if the fire is ready to be lit. Returns a boolean value.
+  def fire_ready?
+    # If fire_progress (value between 0 and 10) is equal to fire_ready_in (value of 10),
+    # the fire is ready to be lit.
+    state.fire_progress == state.fire_ready_in
+  end
 
+  # Divides the value of the fire_progress variable by 10 to determine how close the user is to
+  # being able to light a fire.
+  def light_fire_progress
+    state.fire_progress.fdiv(10) # float division
+  end
 
-# The tick method is called by DragonRuby every frame
-# args contains all the information regarding the game.
-def tick args
-  tick_instructions args, "Sample app shows different version of label sizes and alignments. And how to use hashes instead of arrays."
-  # Here are some examples of simple labels, with the minimum number of parameters
-  # Note that the default values for the other parameters are 0, except for Alpha which is 255 and Font Style which is the default font
-  args.outputs.labels << [400, 620, "Here is a label with just an x, y, and text"]
+  # Defines fire as the state.fire variable.
+  def fire
+    state.fire
+  end
 
-  args.outputs.labels << [args.grid.left.shift_right(5), args.grid.top.shift_down(5), "This is a label located at the top left."]
-  args.outputs.labels << [args.grid.left.shift_right(5), args.grid.bottom.shift_up(30), "This is a label located at the bottom left."]
-  args.outputs.labels << [args.grid.right.shift_left(420), args.grid.top.shift_down(5), "This is a label located at the top right."]
-  args.outputs.labels << [args.grid.right.shift_left(440), args.grid.bottom.shift_up(30), "This is a label located at the bottom right."]
+  # Sets the title of the room.
+  def room_title
+    return "a room that is dark" if state.fire == :dead # room is dark if the fire is dead
+    return "a room that is lit" # room is lit if the fire is not dead
+  end
 
-  # Demonstration of the Size Parameter
-  args.outputs.labels << [175 + 150, 610 - 50, "Smaller label.",  -2]
-  args.outputs.labels << [175 + 150, 580 - 50, "Small label.",    -1]
-  args.outputs.labels << [175 + 150, 550 - 50, "Medium label.",    0]
-  args.outputs.labels << [175 + 150, 520 - 50, "Large label.",     1]
-  args.outputs.labels << [175 + 150, 490 - 50, "Larger label.",    2]
+  # Sets the active_module to room.
+  def go_to_room
+    state.active_module = :room
+  end
 
-  # Demonstration of the Align Parameter
-  args.outputs.labels << [260 + 150, 345 - 50, "Left aligned.",    0, 2]
-  args.outputs.labels << [260 + 150, 325 - 50, "Center aligned.",  0, 1]
-  args.outputs.labels << [260 + 150, 305 - 50, "Right aligned.",   0, 0]
+  # Defines active_module as the state.active_module variable.
+  def active_module
+    state.active_module
+  end
 
-  # Demonstration of the RGBA parameters
-  args.outputs.labels << [600  + 150, 590 - 50, "Red Label.",       0, 0, 255,   0,   0]
-  args.outputs.labels << [600  + 150, 570 - 50, "Green Label.",     0, 0,   0, 255,   0]
-  args.outputs.labels << [600  + 150, 550 - 50, "Blue Label.",      0, 0,   0,   0, 255]
-  args.outputs.labels << [600  + 150, 530 - 50, "Faded Label.",     0, 0,   0,   0,   0, 128]
+  # Defines story_line as the state.story_line variable.
+  def story_line
+    state.story_line
+  end
 
-  # Demonstration of the Font parameter
-  # In order to use a font of your choice, add its ttf file to the project folder, where the app folder is
-  args.outputs.labels << [690 + 150, 330 - 20, "Custom font (Array)", 0, 1, 125, 0, 200, 255, "manaspc.ttf" ]
-  args.outputs.primitives << { x: 690 + 150,
-                               y: 330 - 50,
-                               text: "Custom font (Hash)",
-                               size_enum: 0,
-                               alignment_enum: 1,
-                               r: 125,
-                               g: 0,
-                               b: 200,
-                               a: 255,
-                               font: "manaspc.ttf" }.label
+  # Update every 60 frames (or every second)
+  def should_tick?
+    state.tick_count.mod_zero?(60)
+  end
 
-  # Primitives can hold anything, and can be given a label in the following forms
-  args.outputs.primitives << [690 + 150, 330 - 80, "Custom font (.primitives Array)", 0, 1, 125, 0, 200, 255, "manaspc.ttf" ].label
+  # Sets the value of the game state provider.
+  def initialize game_state_provider
+    @game_state_provider = game_state_provider
+  end
 
-  args.outputs.primitives << { x: 690 + 150,
-                               y: 330 - 110,
-                               text: "Custom font (.primitives Hash)",
-                               size_enum: 0,
-                               alignment_enum: 1,
-                               r: 125,
-                               g: 0,
-                               b: 200,
-                               a: 255,
-                               font: "manaspc.ttf" }.label
-end
+  # Defines the game state.
+  # Any variable prefixed with an @ symbol is an instance variable.
+  def state
+    @game_state_provider.state
+  end
 
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
+  # Saves the state of the game in a text file called game_state.txt.
+  def save
+    $gtk.serialize_state('game_state.txt', state)
   end
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
-end
+  # Loads the game state from the game_state.txt text file.
+  # If the load is unsuccessful, the user is informed since the story line indicates the failure.
+  def load
+    parsed_state = $gtk.deserialize_state('game_state.txt')
+    if !parsed_state
+      set_story_line "no game to load. press save first."
+    else
+      $gtk.args.state = parsed_state
+    end
+  end
 
-
-Rendering Basics - Lines - main.rb
-# ./samples/01_rendering_basics/02_lines/app/main.rb
-=begin
+  # Resets the game.
+  def reset
+    $gtk.reset
+  end
+end
 
-APIs listing that haven't been encountered in a previous sample apps:
+class TextedBasedGamePresenter
+  attr_accessor :state, :outputs, :inputs
 
-- args.outputs.lines: An array. Values in this array generate lines on
-  the screen.
-- args.state.tick_count: This property contains an integer value that
-  represents the current frame. GTK renders at 60 FPS. A value of 0
-  for args.state.tick_count represents the initial load of the game.
+  # Creates empty collection called highlights.
+  # Calls methods necessary to run the game.
+  def tick
+    state.layout.highlights ||= []
+    game.tick if game.should_tick?
+    render
+    process_input
+  end
 
-=end
+  # Outputs a label of the tick count (passage of time) and calls all render methods.
+  def render
+    outputs.labels << [10, 30, state.tick_count]
+    render_alert
+    render_room
+    render_highlights
+  end
 
-# The parameters required for lines are:
-# 1. The initial point (x, y)
-# 2. The end point (x2, y2)
-# 3. The rgba values for the color and transparency (r, g, b, a)
+  # Outputs a label onto the screen that shows the story line, and also outputs a "close" button.
+  def render_alert
+    return unless game.active_module == :alert
 
-# An example of creating a line would be:
-# args.outputs.lines << [100, 100, 300, 300, 255, 0, 255, 255]
+    outputs.labels << [640, 480, game.story_line, 5, 1]  # outputs story line label
+    outputs.primitives << button(:alert_dismiss, 490, 380, "close")  # positions "close" button under story line
+  end
 
-# This would create a line from (100, 100) to (300, 300)
-# The RGB code (255, 0, 255) would determine its color, a purple
-# It would have an Alpha value of 255, making it completely opaque
+  def render_room
+    return unless game.active_module == :room
+    outputs.labels << [640, 700, game.room_title, 4, 1] # outputs room title label at top of screen
 
-def tick args
-  tick_instructions args, "Sample app shows how to create lines."
+    # The parameters for these outputs are (symbol, x, y, text, value/percentage) and each has a y value
+    # that positions it 60 pixels lower than the previous output.
 
-  args.outputs.labels << [480, 620, "Lines (x, y, x2, y2, r, g, b, a)"]
+    # outputs the light_fire_progress bar, uses light_fire_progress for its percentage (which changes bar's appearance)
+    outputs.primitives << progress_bar(:light_fire, 490, 600, "light fire", game.light_fire_progress)
+    outputs.primitives << button(       :save_game, 490, 540, "save") # outputs save button
+    outputs.primitives << button(       :load_game, 490, 480, "load") # outputs load button
+    outputs.primitives << button(      :reset_game, 490, 420, "reset") # outputs reset button
+    outputs.labels << [640, 30, "the fire is #{game.fire}", 0, 1] # outputs fire label at bottom of screen
+  end
 
-  # Some simple lines
-  args.outputs.lines  << [380, 450, 675, 450]
-  args.outputs.lines  << [380, 410, 875, 410]
+  # Outputs a collection of highlights using an array to set their values, and also rejects certain values from the collection.
+  def render_highlights
+    state.layout.highlights.each do |h| # for each highlight in the collection
+        h.lifetime -= 1 # decrease the value of its lifetime
+      end
 
-  # These examples utilize args.state.tick_count to change the length of the lines over time
-  # args.state.tick_count is the ticks that have occurred in the game
-  # This is accomplished by making either the starting or ending point based on the args.state.tick_count
-  args.outputs.lines  << [380, 370, 875, 370, args.state.tick_count % 255, 0, 0, 255]
-  args.outputs.lines  << [380, 330 - args.state.tick_count % 25, 875, 330, 0, 0, 0, 255]
-  args.outputs.lines  << [380 + args.state.tick_count % 400, 290, 875, 290, 0, 0, 0, 255]
-end
+      outputs.solids << state.layout.highlights.map do |h| # outputs highlights collection
+        [h.x, h.y, h.w, h.h, h.color, 255 * h.lifetime / h.max_lifetime] # sets definition for each highlight
+        # transparency changes; divide lifetime by max_lifetime, multiply result by 255
+      end
 
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
+      # reject highlights from collection that have no remaining lifetime
+      state.layout.highlights = state.layout.highlights.reject { |h| h.lifetime <= 0 }
   end
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
-end
+  # Checks whether or not a button was clicked.
+  # Returns a boolean value.
+  def process_input
+    button = button_clicked? # calls button_clicked? method
+  end
 
-
-Rendering Basics - Solids Borders - main.rb
-# ./samples/01_rendering_basics/03_solids_borders/app/main.rb
-=begin
+  # Returns a boolean value.
+  # Finds the button that was clicked from the button list and determines what method to call.
+  # Adds a highlight to the highlights collection.
+  def button_clicked?
+    return nil unless click_pos # return nil unless click_pos holds coordinates of mouse click
+      button = @button_list.find do |k, v| # goes through button_list to find button clicked
+        click_pos.inside_rect? v[:primitives].last.rect # was the mouse clicked inside the rect of button?
+      end
+      return unless button # return unless a button was clicked
+      method_to_call = "#{button[0]}_clicked".to_sym # sets method_to_call to symbol (like :save_game or :load_game)
+      if self.respond_to? method_to_call # returns true if self responds to the given method (method actually exists)
+        border = button[1][:primitives].last # sets border definition using value of last key in button list hash
 
-APIs listing that haven't been encountered in a previous sample apps:
+        # declares each highlight as a new entity, sets properties
+        state.layout.highlights << state.new_entity(:highlight) do |h|
+            h.x = border.x
+            h.y = border.y
+            h.w = border.w
+            h.h = border.h
+            h.max_lifetime = 10
+            h.lifetime = h.max_lifetime
+            h.color = [120, 120, 180] # sets color to shade of purple
+          end
 
-- args.outputs.solids: An array. Values in this array generate
-  solid/filled rectangles on the screen.
+          self.send method_to_call # invoke method identified by symbol
+        else # otherwise, if self doesn't respond to given method
+          border = button[1][:primitives].last # sets border definition using value of last key in hash
 
-=end
+          # declares each highlight as a new entity, sets properties
+          state.layout.highlights << state.new_entity(:highlight) do |h|
+            h.x = border.x
+            h.y = border.y
+            h.w = border.w
+            h.h = border.h
+            h.max_lifetime = 4 # different max_lifetime than the one set if respond_to? had been true
+            h.lifetime = h.max_lifetime
+            h.color = [120, 80, 80] # sets color to dark color
+          end
 
-# Rects are outputted in DragonRuby as rectangles
-# If filled in, they are solids
-# If hollow, they are borders
+          # instructions for users on how to add the missing method_to_call to the code
+          puts "It looks like #{method_to_call} doesn't exists on TextedBasedGamePresenter. Please add this method:"
+          puts "Just copy the code below and put it in the #{TextedBasedGamePresenter} class definition."
+          puts ""
+          puts "```"
+          puts "class TextedBasedGamePresenter <--- find this class and put the method below in it"
+          puts ""
+          puts "  def #{method_to_call}"
+          puts "    puts 'Yay that worked!'"
+          puts "  end"
+          puts ""
+          puts "end <-- make sure to put the #{method_to_call} method in between the `class` word and the final `end` statement."
+          puts "```"
+          puts ""
+      end
+  end
 
-# Solids are added to args.outputs.solids
-# Borders are added to args.outputs.borders
+  # Returns the position of the mouse when it is clicked.
+  def click_pos
+    return nil unless inputs.mouse.click # returns nil unless the mouse was clicked
+    return inputs.mouse.click.point # returns location of mouse click (coordinates)
+  end
 
-# The parameters required for rects are:
-# 1. The upper right corner (x, y)
-# 2. The width (w)
-# 3. The height (h)
-# 4. The rgba values for the color and transparency (r, g, b, a)
+  # Creates buttons for the button_list and sets their values using a hash (uses symbols as keys)
+  def button id, x, y, text
+    @button_list[id] ||= { # assigns values to hash keys
+      id: id,
+      text: text,
+      primitives: [
+        [x + 10, y + 30, text, 2, 0].label, # positions label inside border
+        [x, y, 300, 50].border,             # sets definition of border
+      ]
+    }
 
-# Here is an example of a rect definition:
-# [100, 100, 400, 500, 0, 255, 0, 180]
+    @button_list[id][:primitives] # returns label and border for buttons
+  end
 
-# The example would create a rect from (100, 100)
-# Extending 400 pixels across the x axis
-# and 500 pixels across the y axis
-# The rect would be green (0, 255, 0)
-# and mostly opaque with some transparency (180)
+  # Creates a progress bar (used for lighting the fire) and sets its values.
+  def progress_bar id, x, y, text, percentage
+    @button_list[id] = { # assigns values to hash keys
+      id: id,
+      text: text,
+      primitives: [
+        [x, y, 300, 50, 100, 100, 100].solid, # sets definition for solid (which fills the bar with gray)
+        [x + 10, y + 30, text, 2, 0].label, # sets definition for label, positions inside border
+        [x, y, 300, 50].border, # sets definition of border
+      ]
+    }
 
-# Whether the rect would be filled or not depends on if
-# it is added to args.outputs.solids or args.outputs.borders
+    # Fills progress bar based on percentage. If the fire was ready to be lit (100%) and we multiplied by
+    # 100, only 1/3 of the bar would only be filled in. 200 would cause only 2/3 to be filled in.
+    @button_list[id][:primitives][0][2] = 300 * percentage
+    @button_list[id][:primitives]
+  end
 
+  # Defines the game.
+  def game
+    @game
+  end
 
-def tick args
-  tick_instructions args, "Sample app shows how to create solid squares."
-  args.outputs.labels << [460, 600, "Solids (x, y, w, h, r, g, b, a)"]
-  args.outputs.solids << [470, 520, 50, 50]
-  args.outputs.solids << [530, 520, 50, 50, 0, 0, 0]
-  args.outputs.solids << [590, 520, 50, 50, 255, 0, 0]
-  args.outputs.solids << [650, 520, 50, 50, 255, 0, 0, 128]
-  args.outputs.solids << [710, 520, 50, 50, 0, 0, 0, 128 + args.state.tick_count % 128]
+  # Initalizes the game and creates an empty list of buttons.
+  def initialize
+    @game = TextedBasedGame.new self
+    @button_list ||= {}
+  end
 
+  # Clears the storyline and takes the user to the room.
+  def alert_dismiss_clicked
+    game.clear_storyline
+    game.go_to_room
+  end
 
-  args.outputs.labels <<  [460, 400, "Borders (x, y, w, h, r, g, b, a)"]
-  args.outputs.borders << [470, 320, 50, 50]
-  args.outputs.borders << [530, 320, 50, 50, 0, 0, 0]
-  args.outputs.borders << [590, 320, 50, 50, 255, 0, 0]
-  args.outputs.borders << [650, 320, 50, 50, 255, 0, 0, 128]
-  args.outputs.borders << [710, 320, 50, 50, 0, 0, 0, 128 + args.state.tick_count % 128]
-end
+  # Lights the fire when the user clicks the "light fire" option.
+  def light_fire_clicked
+    game.light_fire
+  end
 
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
+  # Saves the game when the user clicks the "save" option.
+  def save_game_clicked
+    game.save
   end
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+  # Resets the game when the user clicks the "reset" option.
+  def reset_game_clicked
+    game.reset
+  end
+
+  # Loads the game when the user clicks the "load" option.
+  def load_game_clicked
+    game.load
+  end
 end
 
-
-Rendering Basics - Sprites - main.rb
-# ./samples/01_rendering_basics/04_sprites/app/main.rb
-=begin
+$text_based_rpg = TextedBasedGamePresenter.new
 
-APIs listing that haven't been encountered in a previous sample apps:
+def tick args
+  $text_based_rpg.state = args.state
+  $text_based_rpg.outputs = args.outputs
+  $text_based_rpg.inputs = args.inputs
+  $text_based_rpg.tick
+end
 
-- args.outputs.sprites: An array. Values in this array generate
-  sprites on the screen. The location of the sprite is assumed to
-  be under the mygame/ directory (the exception being dragonruby.png).
+
+Advanced Rendering - Simple Render Targets - main.rb
+# ./samples/07_advanced_rendering/01_simple_render_targets/app/main.rb
+def tick args
+  # args.outputs.render_targets are really really powerful.
+  # They essentially allow you to create a sprite programmatically and cache the result.
 
-=end
+  # Create a render_target of a :block and a :gradient on tick zero.
+  if args.state.tick_count == 0
+    args.render_target(:block).solids << [0, 0, 1280, 100]
 
+    # The gradient is actually just a collection of black solids with increasing
+    # opacities.
+    args.render_target(:gradient).solids << 90.map_with_index do |x|
+      50.map_with_index do |y|
+        [x * 15, y * 15, 15, 15, 0, 0, 0, (x * 3).fdiv(255) * 255]
+      end
+    end
+  end
 
-# For all other display outputs, Sprites are your solution
-# Sprites import images and display them with a certain rectangular area
-# The image can be of any usual format and should be located within the folder,
-# similar to additional fonts.
+  # Take the :block render_target and present it horizontally centered.
+  # Use a subsection of the render_targetd specified by source_x,
+  # source_y, source_w, source_h.
+  args.outputs.sprites << { x: 0,
+                            y: 310,
+                            w: 1280,
+                            h: 100,
+                            path: :block,
+                            source_x: 0,
+                            source_y: 0,
+                            source_w: 1280,
+                            source_h: 100 }
 
-# Sprites have the following parameters
-# Rectangular area (x, y, width, height)
-# The image (path)
-# Rotation (angle)
-# Alpha (a)
+  # After rendering :block, render gradient on top of :block.
+  args.outputs.sprites << [0, 0, 1280, 720, :gradient]
 
-def tick args
-  tick_instructions args, "Sample app shows how to render a sprite. Set its alpha, and rotate it."
-  args.outputs.labels <<  [460, 600, "Sprites (x, y, w, h, path, angle, a)"]
-  args.outputs.sprites << [460, 470, 128, 101, 'dragonruby.png']
-  args.outputs.sprites << [610, 470, 128, 101, 'dragonruby.png', args.state.tick_count % 360]
-  args.outputs.sprites << [760, 470, 128, 101, 'dragonruby.png', 0, args.state.tick_count % 255]
+  args.outputs.labels  << [1270, 710, args.gtk.current_framerate, 0, 2, 255, 255, 255]
+  tick_instructions args, "Sample app shows how to use render_targets (programmatically create cached sprites)."
 end
 
 def tick_instructions args, text, y = 715
@@ -3128,183 +11583,91 @@ def tick_instructions args, text, y = 715
   args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
 end
 
-

-Rendering Basics - Sounds - main.rb
-# ./samples/01_rendering_basics/05_sounds/app/main.rb
-=begin
-
- APIs Listing that haven't been encountered in previous sample apps:
-
- - sample: Chooses random element from array.
-   In this sample app, the target note is set by taking a sample from the collection
-   of available notes.
-
- Reminders:
- - args.grid.(left|right|top|bottom): Pixel value for the boundaries of the virtual
-   720 p screen (Dragon Ruby Game Toolkits's virtual resolution is always 1280x720).
-
- - args.state.new_entity: Used when we want to create a new object, like a sprite or button.
-   For example, if we want to create a new button, we would declare it as a new entity and
-   then define its properties.
-
- - String interpolation: Uses #{} syntax; everything between the #{ and the } is evaluated
-   as Ruby code, and the placeholder is replaced with its corresponding value or result.
-
- - args.outputs.labels: An array. The values generate a label.
-   The parameters are [X, Y, TEXT, SIZE, ALIGNMENT, RED, GREEN, BLUE, ALPHA, FONT STYLE]
-   For more information about labels, go to mygame/documentation/02-labels.md.
-
- - reject: Removes elements from a collection if they meet certain requirements.
-
- - first: Returns the first element of an array.
-
- - inside_rect: Returns true or false depending on if the point is inside the rect.
-
- - to_sym: Returns symbol corresponding to string. Will create a symbol if it does
-   not already exist.
+$gtk.reset
 
-=end
+
+Advanced Rendering - Render Targets With Tile Manipulation - main.rb
+# ./samples/07_advanced_rendering/02_render_targets_with_tile_manipulation/app/main.rb
+# This sample is meant to show you how to do that dripping transition thing
+#  at the start of the original Doom. Most of this file is here to animate
+#  a scene to wipe away; the actual wipe effect is in the last 20 lines or
+#  so.
 
-# This sample app allows users to test their musical skills by matching the piano sound that plays in each
-# level to the correct note.
+$gtk.reset   # reset all game state if reloaded.
 
-# Runs all the methods necessary for the game to function properly.
-def tick args
-  defaults args
-  render args
-  calc args
-  input_mouse args
-  tick_instructions args, "Sample app shows how to play sounds. args.outputs.sounds << \"path_to_wav.wav\""
-end
+def circle_of_blocks pass, xoffset, yoffset, angleoffset, blocksize, distance
+  numblocks = 10
 
-# Sets default values and creates empty collections
-# Initialization happens in the first frame only
-def defaults _
-  _.state.notes ||= []
-  _.state.click_feedbacks ||= []
-  _.state.current_level ||= 1
-  _.state.times_wrong ||= 0 # when game starts, user hasn't guessed wrong yet
+  for i in 1..numblocks do
+    angle = ((360 / numblocks) * i) + angleoffset
+    radians = angle * (Math::PI / 180)
+    x = (xoffset + (distance * Math.cos(radians))).round
+    y = (yoffset + (distance * Math.sin(radians))).round
+    pass.solids << [ x, y, blocksize, blocksize, 255, 255, 0 ]
+  end
 end
 
-# Uses a label to display current level, and shows the score
-# Creates a button to play the sample note, and displays the available notes that could be a potential match
-def render _
-
-  # grid.w_half positions the label in the horizontal center of the screen.
-  _.outputs.labels << [_.grid.w_half, _.grid.top.shift_down(40), "Hole #{_.state.current_level} of 9", 0, 1, 0, 0, 0]
-
-  render_score _ # shows score on screen
+def draw_scene args, pass
+  pass.solids << [0, 360, 1280, 360, 0, 0, 200]
+  pass.solids << [0, 0, 1280, 360, 0, 127, 0]
 
-  if _.state.game_over # if game is over, a "play again" button is shown
-    # Calculations ensure that Play Again label is displayed in center of border
-    # Remove calculations from y parameters and see what happens to border and label placement
-    _.state.play_again_border ||= _.state.with_meta([560, _.grid.h * 3 / 4 - 40, 160, 60], 'again') # array definition, text/title
-    _.outputs.labels <<  [_.grid.w_half, _.grid.h * 3 / 4, "Play Again", 0, 1, 0, 0, 0] # outputs label
-    _.outputs.borders << _.state.play_again_border # outputs border
-  else # otherwise, if game is not over
-    # Calculations ensure that label appears in center of border
-    _.state.play_note_border ||= _.state.with_meta([560, _.grid.h * 3 / 4 - 40, 160, 60], 'play') # array definition, text/title
-    _.outputs.labels <<  [_.grid.w_half, _.grid.h * 3 / 4, "Play Note ##{_.state.current_level}", 0, 1, 0, 0, 0] # outputs label
-    _.outputs.borders << _.state.play_note_border # outputs border
-  end
+  blocksize = 100
+  angleoffset = args.state.tick_count * 2.5
+  centerx = (1280 - blocksize) / 2
+  centery = (720 - blocksize) / 2
 
-  return if _.state.game_over # return if game is over
+  circle_of_blocks pass, centerx, centery, angleoffset, blocksize * 2, 500
+  circle_of_blocks pass, centerx, centery, angleoffset, blocksize, 325
+  circle_of_blocks pass, centerx, centery, angleoffset, blocksize / 2, 200
+  circle_of_blocks pass, centerx, centery, angleoffset, blocksize / 4, 100
+end
 
-  _.outputs.labels <<   [_.grid.w_half, 400, "I think the note is a(n)...",  0, 1, 0, 0, 0] # outputs label
+def tick args
+  segments = 160
 
-  # Shows all of the available notes that can be potential matches.
-  available_notes.each_with_index do |note, i|
-    _.state.notes[i] ||= piano_button(_, note, i + 1) # calls piano_button method on each note (creates label and border)
-    _.outputs.labels <<   _.state.notes[i].label # outputs note on screen with a label and a border
-    _.outputs.borders <<  _.state.notes[i].border
+  # On the first tick, initialize some stuff.
+  if !args.state.yoffsets
+    args.state.baseyoff = 0
+    args.state.yoffsets = []
+    for i in 0..segments do
+      args.state.yoffsets << rand * 100
+    end
   end
 
-  # Shows whether or not the user is correct by filling the screen with either red or green
-  _.outputs.solids << _.state.click_feedbacks.map { |c| c.solid }
-end
-
-# Shows the score (number of times the user guesses wrong) onto the screen using labels.
-def render_score _
-  if _.state.times_wrong == 0 # if the user has guessed wrong zero times, the score is par
-    _.outputs.labels << [_.grid.w_half, _.grid.top.shift_down(80), "Score: PAR", 0, 1, 0, 0, 0]
-  else # otherwise, number of times the user has guessed wrong is shown
-    _.outputs.labels << [_.grid.w_half, _.grid.top.shift_down(80), "Score: +#{_.state.times_wrong}", 0, 1, 0, 0, 0] # shows score using string interpolation
+  # Just draw some random stuff for a few seconds.
+  args.state.static_debounce ||= 60 * 2.5
+  if args.state.static_debounce > 0
+    last_frame = args.state.static_debounce == 1
+    target = last_frame ? args.render_target(:last_frame) : args.outputs
+    draw_scene args, target
+    args.state.static_debounce -= 1
+    return unless last_frame
   end
-end
-
-# Sets the target note for the level and performs calculations on click_feedbacks.
-def calc _
-  _.state.target_note ||= available_notes.sample # chooses a note from available_notes collection as target note
-  _.state.click_feedbacks.each    { |c| c.solid[-1] -= 5 } # remove this line and solid color will remain on screen indefinitely
-  # comment this line out and the solid color will keep flashing on screen instead of being removed from click_feedbacks collection
-  _.state.click_feedbacks.reject! { |c| c.solid[-1] <= 0 }
-end
-
-# Uses input from the user to play the target note, as well as the other notes that could be a potential match.
-def input_mouse _
-  return unless _.inputs.mouse.click # return unless the mouse is clicked
-
-  # finds button that was clicked by user
-  button_clicked = _.outputs.borders.find_all do |b| # go through borders collection to find all borders that meet requirements
-    _.inputs.mouse.click.point.inside_rect? b # find button border that mouse was clicked inside of
-  end.reject {|b| !_.state.meta(b)}.first # reject, return first element
 
-  return unless button_clicked # return unless button_clicked as a value (a button was clicked)
+  # build up the wipe...
 
-  queue_click_feedback _, # calls queue_click_feedback method on the button that was clicked
-                       button_clicked.x,
-                       button_clicked.y,
-                       button_clicked.w,
-                       button_clicked.h,
-                       150, 100, 200 # sets color of button to shade of purple
+  # this is the thing we're wiping to.
+  args.outputs.sprites << [ 0, 0, 1280, 720, 'dragonruby.png' ]
 
-  if _.state.meta(button_clicked) == 'play' # if "play note" button is pressed
-    _.outputs.sounds << "sounds/#{_.state.target_note}.wav" # sound of target note is output
-  elsif _.state.meta(button_clicked) == 'again' # if "play game again" button is pressed
-    _.state.target_note = nil # no target note
-    _.state.current_level = 1 # starts at level 1 again
-    _.state.times_wrong = 0 # starts off with 0 wrong guesses
-    _.state.game_over = false # the game is not over (because it has just been restarted)
-  else # otherwise if neither of those buttons were pressed
-    _.outputs.sounds << "sounds/#{_.state.meta(button_clicked)}.wav" # sound of clicked note is played
-    if _.state.meta(button_clicked).to_sym == _.state.target_note # if clicked note is target note
-      _.state.target_note = nil # target note is emptied
+  return if (args.state.baseyoff > (1280 + 100))  # stop when done sliding
 
-      if _.state.current_level < 9 # if game hasn't reached level 9
-        _.state.current_level += 1 # game goes to next level
-      else # otherwise, if game has reached level 9
-        _.state.game_over = true # the game is over
-      end
+  segmentw = 1280 / segments
 
-      queue_click_feedback _, 0, 0, _.grid.w, _.grid.h, 100, 200, 100 # green shown if user guesses correctly
-    else # otherwise, if clicked note is not target note
-      _.state.times_wrong += 1 # increments times user guessed wrong
-      queue_click_feedback _, 0, 0, _.grid.w, _.grid.h, 200, 100, 100 # red shown is user guesses wrong
+  x = 0
+  for i in 0..segments do
+    yoffset = 0
+    if args.state.yoffsets[i] < args.state.baseyoff
+      yoffset = args.state.baseyoff - args.state.yoffsets[i]
     end
-  end
-end
-
-# Creates a collection of all of the available notes as symbols
-def available_notes
-  [:C3, :D3, :E3, :F3, :G3, :A3, :B3, :C4]
-end
 
-# Creates buttons for each note, and sets a label (the note's name) and border for each note's button.
-def piano_button _, note, position
-  _.state.new_entity(:button) do |b| # declares button as new entity
-    b.label  =  [460 + 40.mult(position), _.grid.h * 0.4, "#{note}", 0, 1, 0, 0, 0] # label definition
-    b.border =  _.state.with_meta([460 + 40.mult(position) - 20, _.grid.h * 0.4 - 32, 40, 40], note) # border definition, text/title; 20 subtracted so label is in center of border
+    # (720 - yoffset) flips the coordinate system, (- 720) adjusts for the height of the segment.
+    args.outputs.sprites << [ x, (720 - yoffset) - 720, segmentw, 720, 'last_frame', 0, 255, 255, 255, 255, x, 0, segmentw, 720 ]
+    x += segmentw
   end
-end
 
-# Color of click feedback changes depending on what button was clicked, and whether the guess is right or wrong
-# If a button is clicked, the inside of button is purple (see input_mouse method)
-# If correct note is clicked, screen turns green
-# If incorrect note is clicked, screen turns red (again, see input_mouse method)
-def queue_click_feedback _, x, y, w, h, *color
-  _.state.click_feedbacks << _.state.new_entity(:click_feedback) do |c| # declares feedback as new entity
-    c.solid =  [x, y, w, h, *color, 255] # sets color
-  end
+  args.state.baseyoff += 4
+
+  tick_instructions args, "Sample app shows an advanced usage of render_target."
 end
 
 def tick_instructions args, text, y = 715
@@ -3321,9854 +11684,14227 @@ def tick_instructions args, text, y = 715
   args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
 end
 
-

-Rendering Basics - Audio Mixer - main.rb
-# ./samples/01_rendering_basics/06_audio_mixer/app/main.rb
-$gtk.reset
+
+Advanced Rendering - Render Target Viewports - main.rb
+# ./samples/07_advanced_rendering/03_render_target_viewports/app/main.rb
+=begin
 
-$boxsize = 30
+ APIs listing that haven't been encountered in previous sample apps:
 
-def render_sources args
-  mouse_in_panel = (args.state.selected != 0) && args.inputs.mouse.position.inside_rect?([900, 450, 340, 250])
-  mouse_new_down = (args.state.mouse_held == 1)
+ - args.state.new_entity: Used when we want to create a new object, like a sprite or button.
+   For example, if we want to create a new button, we would declare it as a new entity and
+   then define its properties. (Remember, you can use state to define ANY property and it will
+   be retained across frames.)
 
-  if (mouse_new_down && !mouse_in_panel)
-    args.state.selected = 0  # will reset below if we hit something.
-  end
+   If you have a solar system and you're creating args.state.sun and setting its image path to an
+   image in the sprites folder, you would do the following:
+   (See samples/99_sample_nddnug_workshop for more details.)
 
-  args.audio.keys.each { |k|
-    s = args.audio[k]
+   args.state.sun ||= args.state.new_entity(:sun) do |s|
+   s.path = 'sprites/sun.png'
+   end
 
-    if (mouse_new_down) && !mouse_in_panel && args.inputs.mouse.position.inside_rect?([s[:screenx], s[:screeny], $boxsize, $boxsize])
-      args.state.selected = k
-      args.state.dragging_source = true
-    end
+ - String interpolation: Uses #{} syntax; everything between the #{ and the } is evaluated
+   as Ruby code, and the placeholder is replaced with its corresponding value or result.
 
-    isselected = (k == args.state.selected)
+   For example, if we have a variable
+   name = "Ruby"
+   then the line
+   puts "How are you, #{name}?"
+   would print "How are you, Ruby?" to the console.
+   (Remember, string interpolation only works with double quotes!)
 
-    if isselected && args.state.dragging_source
-      # you can hang anything on the audio hashes you want, so we store the
-      #  actual screen position so it doesn't scale weirdly vs your mouse.
-      s[:screenx] = args.inputs.mouse.x - ($boxsize / 2)
-      s[:screeny] = args.inputs.mouse.y - ($boxsize / 2)
+ - Ternary operator (?): Similar to if statement; first evalulates whether a statement is
+   true or false, and then executes a command depending on that result.
+   For example, if we had a variable
+   grade = 75
+   and used the ternary operator in the command
+   pass_or_fail = grade > 65 ? "pass" : "fail"
+   then the value of pass_or_fail would be "pass" since grade's value was greater than 65.
 
-      s[:screeny] = 50 if s[:screeny] < 50
-      s[:screeny] = (719 - $boxsize) if s[:screeny] > (719 - $boxsize)
-      s[:screenx] = 0 if s[:screenx] < 0
-      s[:screenx] = (1279 - $boxsize) if s[:screenx] > (1279 - $boxsize)
+ Reminders:
 
-      s[:x] = ((s[:screenx] / 1279.0) * 2.0) - 1.0  # scale to -1.0 - 1.0 range
-      s[:y] = ((s[:screeny] / 719.0) * 2.0) - 1.0   # scale to -1.0 - 1.0 range
-    end
+ - args.grid.(left|right|top|bottom): Pixel value for the boundaries of the virtual
+   720 p screen (Dragon Ruby Game Toolkits's virtual resolution is always 1280x720).
 
-    color = isselected ? [ 0, 255, 0, 255 ] : [ 0, 0, 255, 255 ]
-    args.outputs.primitives << [s[:screenx], s[:screeny], $boxsize, $boxsize, *color].solid
-  }
-end
+ - Numeric#shift_(left|right|up|down): Shifts the Numeric in the correct direction
+   by adding or subracting.
 
-def render_panel args
-  s = args.audio[args.state.selected]
-  return if s.nil?
-  mouse_down = (args.state.mouse_held > 0)
+ - ARRAY#inside_rect?: An array with at least two values is considered a point. An array
+   with at least four values is considered a rect. The inside_rect? function returns true
+   or false depending on if the point is inside the rect.
 
-  args.outputs.primitives << [900, 450, 340, 250, 127, 127, 200, 255].solid
-  args.outputs.primitives << [1075, 690, "Source ##{args.state.selected}", 3, 1, 255, 255, 255].label
-  args.outputs.primitives << [910, 660, 1230, 660, 255, 255, 255].line
-  args.outputs.primitives << [910, 650, "screen:    (#{s[:screenx].to_i}, #{s[:screeny].to_i})", 0, 0, 255, 255, 255].label
-  args.outputs.primitives << [910, 625, "position:  (#{s[:x].round(5).to_s[0..6]}, #{s[:y].round(5).to_s[0..6]})", 0, 0, 255, 255, 255].label
+ - ARRAY#intersect_rect?: Returns true or false depending on if the two rectangles intersect.
 
-  slider = [1022, 586, 200, 7]
-  if mouse_down && args.inputs.mouse.position.inside_rect?(slider)
-    s[:pitch] = ((args.inputs.mouse.x - slider[0]).to_f / (slider[2]-1.0)) * 2.0
+ - args.inputs.mouse.click: This property will be set if the mouse was clicked.
+   For more information about the mouse, go to mygame/documentation/07-mouse.md.
+
+ - args.inputs.keyboard.key_up.KEY: The value of the properties will be set
+   to the frame  that the key_up event occurred (the frame correlates
+   to args.state.tick_count).
+   For more information about the keyboard, go to mygame/documentation/06-keyboard.md.
+
+ - args.state.labels:
+   The parameters for a label are
+   1. the position (x, y)
+   2. the text
+   3. the size
+   4. the alignment
+   5. the color (red, green, and blue saturations)
+   6. the alpha (or transparency)
+   For more information about labels, go to mygame/documentation/02-labels.md.
+
+ - args.state.lines:
+   The parameters for a line are
+   1. the starting position (x, y)
+   2. the ending position (x2, y2)
+   3. the color (red, green, and blue saturations)
+   4. the alpha (or transparency)
+   For more information about lines, go to mygame/documentation/04-lines.md.
+
+ - args.state.solids (and args.state.borders):
+   The parameters for a solid (or border) are
+   1. the position (x, y)
+   2. the width (w)
+   3. the height (h)
+   4. the color (r, g, b)
+   5. the alpha (or transparency)
+   For more information about solids and borders, go to mygame/documentation/03-solids-and-borders.md.
+
+ - args.state.sprites:
+   The parameters for a sprite are
+   1. the position (x, y)
+   2. the width (w)
+   3. the height (h)
+   4. the image path
+   5. the angle
+   6. the alpha (or transparency)
+   For more information about sprites, go to mygame/documentation/05-sprites.md.
+=end
+
+# This sample app shows different objects that can be used when making games, such as labels,
+# lines, sprites, solids, buttons, etc. Each demo section shows how these objects can be used.
+
+# Also note that state.tick_count refers to the passage of time, or current frame.
+
+class TechDemo
+  attr_accessor :inputs, :state, :outputs, :grid, :args
+
+  # Calls all methods necessary for the app to run properly.
+  def tick
+    labels_tech_demo
+    lines_tech_demo
+    solids_tech_demo
+    borders_tech_demo
+    sprites_tech_demo
+    keyboards_tech_demo
+    controller_tech_demo
+    mouse_tech_demo
+    point_to_rect_tech_demo
+    rect_to_rect_tech_demo
+    button_tech_demo
+    export_game_state_demo
+    window_state_demo
+    render_seperators
   end
-  slidercolor = (s[:pitch] / 2.0) * 255
-  args.outputs.primitives << [*slider, slidercolor, slidercolor, slidercolor, 255].solid
-  args.outputs.primitives << [910, 600, "pitch: #{s[:pitch].round(3).to_s[0..2]}", 0, 0, 255, 255, 255].label
 
-  slider = [1022, 561, 200, 7]
-  if mouse_down && args.inputs.mouse.position.inside_rect?(slider)
-    s[:gain] = (args.inputs.mouse.x - slider[0]).to_f / (slider[2]-1.0)
+  # Shows output of different kinds of labels on the screen
+  def labels_tech_demo
+    outputs.labels << [grid.left.shift_right(5), grid.top.shift_down(5), "This is a label located at the top left."]
+    outputs.labels << [grid.left.shift_right(5), grid.bottom.shift_up(30), "This is a label located at the bottom left."]
+    outputs.labels << [ 5, 690, "Labels (x, y, text, size, align, r, g, b, a)"]
+    outputs.labels << [ 5, 660, "Smaller label.",  -2]
+    outputs.labels << [ 5, 630, "Small label.",    -1]
+    outputs.labels << [ 5, 600, "Medium label.",    0]
+    outputs.labels << [ 5, 570, "Large label.",     1]
+    outputs.labels << [ 5, 540, "Larger label.",    2]
+    outputs.labels << [300, 660, "Left aligned.",    0, 2]
+    outputs.labels << [300, 640, "Center aligned.",  0, 1]
+    outputs.labels << [300, 620, "Right aligned.",   0, 0]
+    outputs.labels << [175, 595, "Red Label.",       0, 0, 255,   0,   0]
+    outputs.labels << [175, 575, "Green Label.",     0, 0,   0, 255,   0]
+    outputs.labels << [175, 555, "Blue Label.",      0, 0,   0,   0, 255]
+    outputs.labels << [175, 535, "Faded Label.",     0, 0,   0,   0,   0, 128]
   end
-  slidercolor = s[:gain] * 255
-  args.outputs.primitives << [*slider, slidercolor, slidercolor, slidercolor, 255].solid
-  args.outputs.primitives << [910, 575, "gain: #{s[:gain].round(3).to_s[0..2]}", 0, 0, 255, 255, 255].label
 
-  checkbox = [1022, 533, 10, 12]
-  if (args.state.mouse_held == 1) && args.inputs.mouse.position.inside_rect?(checkbox)
-    s[:looping] = !s[:looping]
+  # Shows output of lines on the screen
+  def lines_tech_demo
+    outputs.labels << [5, 500, "Lines (x, y, x2, y2, r, g, b, a)"]
+    outputs.lines  << [5, 450, 100, 450]
+    outputs.lines  << [5, 430, 300, 430]
+    outputs.lines  << [5, 410, 300, 410, state.tick_count % 255, 0, 0, 255] # red saturation changes
+    outputs.lines  << [5, 390 - state.tick_count % 25, 300, 390, 0, 0, 0, 255] # y position changes
+    outputs.lines  << [5 + state.tick_count % 200, 360, 300, 360, 0, 0, 0, 255] # x position changes
+  end
+
+  # Shows output of different kinds of solids on the screen
+  def solids_tech_demo
+    outputs.labels << [  5, 350, "Solids (x, y, w, h, r, g, b, a)"]
+    outputs.solids << [ 10, 270, 50, 50]
+    outputs.solids << [ 70, 270, 50, 50, 0, 0, 0]
+    outputs.solids << [130, 270, 50, 50, 255, 0, 0]
+    outputs.solids << [190, 270, 50, 50, 255, 0, 0, 128]
+    outputs.solids << [250, 270, 50, 50, 0, 0, 0, 128 + state.tick_count % 128] # transparency changes
+  end
+
+  # Shows output of different kinds of borders on the screen
+  # The parameters for a border are the same as the parameters for a solid
+  def borders_tech_demo
+    outputs.labels <<  [  5, 260, "Borders (x, y, w, h, r, g, b, a)"]
+    outputs.borders << [ 10, 180, 50, 50]
+    outputs.borders << [ 70, 180, 50, 50, 0, 0, 0]
+    outputs.borders << [130, 180, 50, 50, 255, 0, 0]
+    outputs.borders << [190, 180, 50, 50, 255, 0, 0, 128]
+    outputs.borders << [250, 180, 50, 50, 0, 0, 0, 128 + state.tick_count % 128] # transparency changes
+  end
+
+  # Shows output of different kinds of sprites on the screen
+  def sprites_tech_demo
+    outputs.labels <<  [   5, 170, "Sprites (x, y, w, h, path, angle, a)"]
+    outputs.sprites << [  10, 40, 128, 101, 'dragonruby.png']
+    outputs.sprites << [ 150, 40, 128, 101, 'dragonruby.png', state.tick_count % 360] # angle changes
+    outputs.sprites << [ 300, 40, 128, 101, 'dragonruby.png', 0, state.tick_count % 255] # transparency changes
   end
-  checkboxcolor = s[:looping] ? 255 : 0
-  args.outputs.primitives << [*checkbox, checkboxcolor, checkboxcolor, checkboxcolor, 255].solid
-  args.outputs.primitives << [910, 550, "looping:", 0, 0, 255, 255, 255].label
 
-  checkbox = [1022, 508, 10, 12]
-  if (args.state.mouse_held == 1) && args.inputs.mouse.position.inside_rect?(checkbox)
-    s[:paused] = !s[:paused]
+  # Holds size, alignment, color (black), and alpha (transparency) parameters
+  # Using small_font as a parameter accounts for all remaining parameters
+  # so they don't have to be repeatedly typed
+  def small_font
+    [-2, 0, 0, 0, 0, 255]
   end
-  checkboxcolor = s[:paused] ? 255 : 0
-  args.outputs.primitives << [*checkbox, checkboxcolor, checkboxcolor, checkboxcolor, 255].solid
-  args.outputs.primitives << [910, 525, "paused:", 0, 0, 255, 255, 255].label
 
-  button = [910, 460, 320, 20]
-  if (args.state.mouse_held == 1) && args.inputs.mouse.position.inside_rect?(button)
-    args.audio.delete(args.state.selected)
-    args.state.selected = 0
+  # Sets position of each row
+  # Converts given row value to pixels that DragonRuby understands
+  def row_to_px row_number
+
+    # Row 0 starts 5 units below the top of the grid.
+    # Each row afterward is 20 units lower.
+    grid.top.shift_down(5).shift_down(20 * row_number)
   end
-  args.outputs.primitives << [*button, 255, 0, 0, 255].solid
-  args.outputs.primitives << [button[0] + (button[2] / 2), button[1]+20, "DELETE SOURCE", 0, 1, 255, 255, 0].label
-end
 
-def spawn_new_sound args, num
-  input = nil
-  input = "sounds/#{num}.#{(num == 6) ? 'ogg' : 'wav'}"
+  # Uses labels to output current game time (passage of time), and whether or not "h" was pressed
+  # If "h" is pressed, the frame is output when the key_up event occurred
+  def keyboards_tech_demo
+    outputs.labels << [460, row_to_px(0), "Current game time: #{state.tick_count}", small_font]
+    outputs.labels << [460, row_to_px(2), "Keyboard input: inputs.keyboard.key_up.h", small_font]
+    outputs.labels << [460, row_to_px(3), "Press \"h\" on the keyboard.", small_font]
 
-  # Spawn randomly in an area that won't be covered by UI.
-  screenx = (rand * 600.0) + 200.0
-  screeny = (rand * 400.0) + 100.0
+    if inputs.keyboard.key_up.h # if "h" key_up event occurs
+      state.h_pressed_at = state.tick_count # frame it occurred is stored
+    end
 
-  args.state.next_sound_index += 1
+    # h_pressed_at is initially set to false, and changes once the user presses the "h" key.
+    state.h_pressed_at ||= false
 
-  # you can hang anything on the audio hashes you want, so we store the
-  #  actual screen position in here for convenience.
-  args.audio[args.state.next_sound_index] = {
-    input: input,
-    screenx: screenx,
-    screeny: screeny,
-    x: ((screenx / 1279.0) * 2.0) - 1.0,  # scale to -1.0 - 1.0 range
-    y: ((screeny / 719.0) * 2.0) - 1.0,   # scale to -1.0 - 1.0 range
-    z: 0.0,
-    gain: 1.0,
-    pitch: 1.0,
-    looping: true,
-    paused: false
-  }
+    if state.h_pressed_at # if h is pressed (pressed_at has a frame number and is no longer false)
+      outputs.labels << [460, row_to_px(4), "\"h\" was pressed at time: #{state.h_pressed_at}", small_font]
+    else # otherwise, label says "h" was never pressed
+      outputs.labels << [460, row_to_px(4), "\"h\" has never been pressed.", small_font]
+    end
 
-  args.state.selected = args.state.next_sound_index
-end
+    # border around keyboard input demo section
+    outputs.borders << [455, row_to_px(5), 360, row_to_px(2).shift_up(5) - row_to_px(5)]
+  end
 
-def render_launcher args
-  total = 6
-  x = (1280 - (total * $boxsize * 3)) / 2
-  y = 10
-  args.outputs.primitives << [0, 0, 1280, ((y*2) + $boxsize), 127, 127, 127, 255].solid
-  for i in 1..total
-    args.outputs.primitives << [x, y, $boxsize, $boxsize, 255, 255, 255, 255].solid
-    args.outputs.primitives << [x+8, y+28, i.to_s, 3, 0, 0, 0, 255, 255].label
-    if args.inputs.mouse.click && args.inputs.mouse.click.point.inside_rect?([x, y, $boxsize, $boxsize])
-      spawn_new_sound args, i
-    end
-    x = x + ($boxsize * 3)
+  # Sets definition for a small label
+  # Makes it easier to position labels in respect to the position of other labels
+  def small_label x, row, message
+    [x, row_to_px(row), message, small_font]
   end
-end
 
-def render_ui args
-  render_launcher args
-  render_panel args
-end
+  # Uses small labels to show whether the "a" button on the controller is down, held, or up.
+  # y value of each small label is set by calling the row_to_px method
+  def controller_tech_demo
+    x = 460
+    outputs.labels << small_label(x, 6, "Controller one input: inputs.controller_one")
+    outputs.labels << small_label(x, 7, "Current state of the \"a\" button.")
+    outputs.labels << small_label(x, 8, "Check console window for more info.")
 
-def tick args
-  args.state.mouse_held ||= 0
-  args.state.dragging_source ||= false
-  args.state.selected ||= 0
-  args.state.next_sound_index ||= 0
+    if inputs.controller_one.key_down.a # if "a" is in "down" state
+      outputs.labels << small_label(x, 9, "\"a\" button down: #{inputs.controller_one.key_down.a}")
+      puts "\"a\" button down at #{inputs.controller_one.key_down.a}" # prints frame the event occurred
+    elsif inputs.controller_one.key_held.a # if "a" is held down
+      outputs.labels << small_label(x, 9, "\"a\" button held: #{inputs.controller_one.key_held.a}")
+    elsif inputs.controller_one.key_up.a # if "a" is in up state
+      outputs.labels << small_label(x, 9, "\"a\" button up: #{inputs.controller_one.key_up.a}")
+      puts "\"a\" key up at #{inputs.controller_one.key_up.a}"
+    else # if no event has occurred
+      outputs.labels << small_label(x, 9, "\"a\" button state is nil.")
+    end
 
-  if args.inputs.mouse.up
-    args.state.mouse_held = 0
-    args.state.dragging_source = false
-  elsif args.inputs.mouse.down || (args.state.mouse_held > 0)
-    args.state.mouse_held += 1
-  else
+    # border around controller input demo section
+    outputs.borders << [455, row_to_px(10), 360, row_to_px(6).shift_up(5) - row_to_px(10)]
   end
 
-  args.outputs.background_color = [ 0, 0, 0, 255 ]
-  render_sources args
-  render_ui args
-end
+  # Outputs when the mouse was clicked, as well as the coordinates on the screen
+  # of where the click occurred
+  def mouse_tech_demo
+    x = 460
 
-

-Rendering Basics - Sound Synthesis - main.rb
-# ./samples/01_rendering_basics/07_sound_synthesis/app/main.rb
-def tick args
-  defaults args
-  render args
-  input args
-  process_audio_queue args
-end
+    outputs.labels << small_label(x, 11, "Mouse input: inputs.mouse")
 
-def defaults args
-  args.state.sine_waves  ||= {}
-  args.state.audio_queue ||= []
-  args.state.buttons     ||= [
-    (frequency_buttons args),
-    (note_buttons args),
-    (bell_buttons args)
-  ].flatten
-end
+    if inputs.mouse.click # if click has a value and is not nil
+      state.last_mouse_click = inputs.mouse.click # coordinates of click are stored
+    end
 
-def frequency_buttons args
-  [
-    (button args,
-            row: 4.0, col: 0, text: "300hz",
-            frequency: 300,
-            method_to_call: :play_sine_wave),
-    (button args,
-            row: 5.0, col: 0, text: "400hz",
-            frequency: 400,
-            method_to_call: :play_sine_wave),
-    (button args,
-            row: 6.0, col: 0, text: "500hz",
-            frequency: 500,
-            method_to_call: :play_sine_wave),
-  ]
-end
+    if state.last_mouse_click # if mouse is clicked (has coordinates as value)
+      # outputs the time (frame) the click occurred, as well as how many frames have passed since the event
+      outputs.labels << small_label(x, 12, "Mouse click happened at: #{state.last_mouse_click.created_at}, #{state.last_mouse_click.created_at_elapsed}")
+      # outputs coordinates of click
+      outputs.labels << small_label(x, 13, "Mouse click location: #{state.last_mouse_click.point.x}, #{state.last_mouse_click.point.y}")
+    else # otherwise if the mouse has not been clicked
+      outputs.labels << small_label(x, 12, "Mouse click has not occurred yet.")
+      outputs.labels << small_label(x, 13, "Please click mouse.")
+    end
+  end
 
-def play_sine_wave args, sender
-  queue_sine_wave args,
-                  frequency: sender[:frequency],
-                  duration: 1.seconds,
-                  fade_out: true
-end
+  # Outputs whether a mouse click occurred inside or outside of a box
+  def point_to_rect_tech_demo
+    x = 460
 
+    outputs.labels << small_label(x, 15, "Click inside the blue box maybe ---->")
 
-def note_buttons args
-  [
-    (button args,
-            row: 1.5, col: 3, text: "C4",
-            note: :c, octave: 4, method_to_call: :play_note),
-    (button args,
-            row: 2.5, col: 3, text: "D4",
-            note: :d, octave: 4, method_to_call: :play_note),
-    (button args,
-            row: 3.5, col: 3, text: "E4",
-            note: :e, octave: 4, method_to_call: :play_note),
-    (button args,
-            row: 4.5, col: 3, text: "F4",
-            note: :f, octave: 4, method_to_call: :play_note),
-    (button args,
-            row: 5.5, col: 3, text: "G4",
-            note: :g, octave: 4, method_to_call: :play_note),
-    (button args,
-            row: 6.5, col: 3, text: "A5",
-            note: :a, octave: 5, method_to_call: :play_note),
-    (button args,
-            row: 7.5, col: 3, text: "B5",
-            note: :b, octave: 5, method_to_call: :play_note),
-    (button args,
-            row: 8.5, col: 3, text: "C5",
-            note: :c, octave: 5, method_to_call: :play_note),
-  ]
-end
+    box = [765, 370, 50, 50, 0, 0, 170] # blue box
+    outputs.borders << box
 
-def play_note args, sender
-  queue_sine_wave args,
-                  frequency: (frequency_for note:   sender[:note],
-                                            octave: sender[:octave]),
-                  duration: 1.seconds,
-                  fade_out: true
-end
+    if state.last_mouse_click # if the mouse was clicked
+      if state.last_mouse_click.point.inside_rect? box # if mouse clicked inside box
+        outputs.labels << small_label(x, 16, "Mouse click happened inside the box.")
+      else # otherwise, if mouse was clicked outside the box
+        outputs.labels << small_label(x, 16, "Mouse click happened outside the box.")
+      end
+    else # otherwise, if was not clicked at all
+      outputs.labels << small_label(x, 16, "Mouse click has not occurred yet.") # output if the mouse was not clicked
+    end
 
-def bell_buttons args
-  [
-    (button args,
-            row: 1.5, col: 6, text: "Bell C4",
-            note: :c, octave: 4, method_to_call: :play_bell),
-    (button args,
-            row: 2.5, col: 6, text: "Bell D4",
-            note: :d, octave: 4, method_to_call: :play_bell),
-    (button args,
-            row: 3.5, col: 6, text: "Bell E4",
-            note: :e, octave: 4, method_to_call: :play_bell),
-    (button args,
-            row: 4.5, col: 6, text: "Bell F4",
-            note: :f, octave: 4, method_to_call: :play_bell),
-    (button args,
-            row: 5.5, col: 6, text: "Bell G4",
-            note: :g, octave: 4, method_to_call: :play_bell),
-    (button args,
-            row: 6.5, col: 6, text: "Bell A5",
-            note: :a, octave: 5, method_to_call: :play_bell),
-    (button args,
-            row: 7.5, col: 6, text: "Bell B5",
-            note: :b, octave: 5, method_to_call: :play_bell),
-    (button args,
-            row: 8.5, col: 6, text: "Bell C5",
-            note: :c, octave: 5, method_to_call: :play_bell),
-  ]
-end
+    # border around mouse input demo section
+    outputs.borders << [455, row_to_px(14), 360, row_to_px(11).shift_up(5) - row_to_px(14)]
+  end
 
-def play_bell args, sender
-  queue_bell args,
-             frequency: (frequency_for note:   sender[:note],
-                                       octave: sender[:octave]),
-             duration: 2.seconds,
-             fade_out: true
-end
+  # Outputs a red box onto the screen. A mouse click from the user inside of the red box will output
+  # a smaller box. If two small boxes are inside of the red box, it will be determined whether or not
+  # they intersect.
+  def rect_to_rect_tech_demo
+    x = 460
 
-def render args
-  args.outputs.borders << args.state.buttons.map { |b| b[:border] }
-  args.outputs.labels  << args.state.buttons.map { |b| b[:label]  }
-  args.outputs.labels  << args.layout
-                              .rect(row: 0,
-                                    col: 11.5)
-                              .yield_self { |r| r.merge y: r.y + r.h }
-                              .merge(text: "This is a Pro only feature. Click here to watch the YouTube video if you are on the Standard License.",
-                                     alignment_enum: 1)
-end
+    outputs.labels << small_label(x, 17.5, "Click inside the red box below.") # label with instructions
+    red_box = [460, 250, 355, 90, 170, 0, 0] # definition of the red box
+    outputs.borders << red_box # output as a border (not filled in)
 
-def input args
-  args.state.buttons.each do |b|
-    if args.inputs.mouse.click.inside_rect? b[:rect]
-      parameter_string = (b.slice :frequency, :note, :octave).map { |k, v| "#{k}: #{v}" }.join ", "
-      args.gtk.notify! "#{b[:method_to_call]} #{parameter_string}"
-      send b[:method_to_call], args, b
+    # If the mouse is clicked inside the red box, two collision boxes are created.
+    if inputs.mouse.click
+      if inputs.mouse.click.point.inside_rect? red_box
+        if !state.box_collision_one # if the collision_one box does not yet have a definition
+          # Subtracts 25 from the x and y positions of the click point in order to make the click point the center of the box.
+          # You can try deleting the subtraction to see how it impacts the box placement.
+          state.box_collision_one = [inputs.mouse.click.point.x - 25, inputs.mouse.click.point.y - 25, 50, 50, 180, 0,   0, 180]  # sets definition
+        elsif !state.box_collision_two # if collision_two does not yet have a definition
+          state.box_collision_two = [inputs.mouse.click.point.x - 25, inputs.mouse.click.point.y - 25, 50, 50,   0, 0, 180, 180] # sets definition
+        else
+          state.box_collision_one = nil # both boxes are empty
+          state.box_collision_two = nil
+        end
+      end
     end
-  end
 
-  if args.inputs.mouse.click.inside_rect? (args.layout.rect(row: 0).yield_self { |r| r.merge y: r.y + r.h.half, h: r.h.half })
-    args.gtk.openurl 'https://www.youtube.com/watch?v=zEzovM5jT-k&ab_channel=AmirRajan'
-  end
-end
+    # If collision boxes exist, they are output onto screen inside the red box as solids
+    if state.box_collision_one
+      outputs.solids << state.box_collision_one
+    end
 
-def process_audio_queue args
-  to_queue = args.state.audio_queue.find_all { |v| v[:queue_at] <= args.tick_count }
-  args.state.audio_queue -= to_queue
+    if state.box_collision_two
+      outputs.solids << state.box_collision_two
+    end
 
-  to_queue.each do |a|
-    args.audio[a[:id]] = a
+    # Outputs whether or not the two collision boxes intersect.
+    if state.box_collision_one && state.box_collision_two # if both collision_boxes are defined (and not nil or empty)
+      if state.box_collision_one.intersect_rect? state.box_collision_two # if the two boxes intersect
+        outputs.labels << small_label(x, 23.5, 'The boxes intersect.')
+      else # otherwise, if the two boxes do not intersect
+        outputs.labels << small_label(x, 23.5, 'The boxes do not intersect.')
+      end
+    else
+      outputs.labels << small_label(x, 23.5, '--') # if the two boxes are not defined (are nil or empty), this label is output
+    end
   end
 
-  args.audio.each do |k, v|
-    if v[:decay_rate]
-      v[:gain] -= v[:decay_rate]
+  # Creates a button and outputs it onto the screen using labels and borders.
+  # If the button is clicked, the color changes to make it look faded.
+  def button_tech_demo
+    x, y, w, h = 460, 160, 300, 50
+    state.button        ||= state.new_entity(:button_with_fade)
+
+    # Adds w.half to x and h.half + 10 to y in order to display the text inside the button's borders.
+    state.button.label  ||= [x + w.half, y + h.half + 10, "click me and watch me fade", 0, 1]
+    state.button.border ||= [x, y, w, h]
+
+    if inputs.mouse.click && inputs.mouse.click.point.inside_rect?(state.button.border) # if mouse is clicked, and clicked inside button's border
+      state.button.clicked_at = inputs.mouse.click.created_at # stores the time the click occurred
+    end
+
+    outputs.labels << state.button.label
+    outputs.borders << state.button.border
+
+    if state.button.clicked_at # if button was clicked (variable has a value and is not nil)
+
+      # The appearance of the button changes for 0.25 seconds after the time the button is clicked at.
+      # The color changes (rgb is set to 0, 180, 80) and the transparency gradually changes.
+      # Change 0.25 to 1.25 and notice that the transparency takes longer to return to normal.
+      outputs.solids << [x, y, w, h, 0, 180, 80, 255 * state.button.clicked_at.ease(0.25.seconds, :flip)]
     end
   end
 
-  sounds_to_stop = args.audio.find_all do |k, v|
-    v[:stop_at] && args.state.tick_count >= v[:stop_at]
+  # Creates a new button by declaring it as a new entity, and sets values.
+  def new_button_prefab x, y, message
+    w, h = 300, 50
+    button        = state.new_entity(:button_with_fade)
+    button.label  = [x + w.half, y + h.half + 10, message, 0, 1] # '+ 10' keeps label's text within button's borders
+    button.border = [x, y, w, h] # sets border definition
+    button
   end
 
-  sounds_to_stop.each do |(k, v)|
-    args.audio.delete k
+  # If the mouse has been clicked and the click's location is inside of the button's border, that means
+  # that the button has been clicked. This method returns a boolean value.
+  def button_clicked? button
+    inputs.mouse.click && inputs.mouse.click.point.inside_rect?(button.border)
   end
-end
 
-def graph_sine_wave args, sine_wave, frequency
-  if args.state.tick_count != args.state.graphed_at
-    args.outputs.static_lines.clear
-    args.outputs.static_sprites.clear
-  end
+  # Determines if button was clicked, and changes its appearance if it is clicked
+  def tick_button_prefab button
+    outputs.labels << button.label # outputs button's label and border
+    outputs.borders << button.border
 
-  r, g, b = frequency.to_i % 80, frequency.to_i % 128, frequency.to_i % 255
-  center_row = args.layout.rect(row: 5, col: 9)
-  x_scale    = 20
-  y_scale    = 100
-  max_points = 20
+    if button_clicked? button # if button is clicked
+      button.clicked_at = inputs.mouse.click.created_at # stores the time that the button was clicked
+    end
 
-  points = sine_wave
-  if sine_wave.length > max_points
-    resolution = sine_wave.length.idiv max_points
-    points = sine_wave.find_all
-                      .with_index { |y, i| i % resolution == 0 }
+    if button.clicked_at # if clicked_at has a frame value and is not nil
+      # button is output; color changes and transparency changes for 0.25 seconds after click occurs
+      outputs.solids << [button.border.x, button.border.y, button.border.w, button.border.h,
+                         0, 180, 80, 255 * button.clicked_at.ease(0.25.seconds, :flip)] # transparency changes for 0.25 seconds
+    end
   end
 
-  args.outputs.static_lines << points.map_with_index do |y, x|
-    next_y = points[x + 1]
-
-    if next_y
-      {
-        x:  center_row.x + (x * x_scale),
-        y:  center_row.y + center_row.h.half + y_scale * y,
-        x2: center_row.x + ((x + 1) * x_scale),
-        y2: center_row.y + center_row.h.half + y_scale * next_y,
-        r:  r,
-        g:  g,
-        b:  b
-      }
+  # Exports the app's game state if the export button is clicked.
+  def export_game_state_demo
+    state.export_game_state_button ||= new_button_prefab(460, 100, "click to export app state")
+    tick_button_prefab(state.export_game_state_button) # calls method to output button
+    if button_clicked? state.export_game_state_button # if the export button is clicked
+      args.gtk.export! "Exported from clicking the export button in the tech demo." # the export occurs
     end
   end
 
-  args.outputs.static_sprites << points.map_with_index do |y, x|
-    {
-      x:  (center_row.x + (x * x_scale)) - 1,
-      y:  (center_row.y + center_row.h.half + y_scale * y) - 1,
-      w:  2,
-      h:  2,
-      path: 'sprites/square-black.png'
-    }
+  # The mouse and keyboard focus are set to "yes" when the Dragonruby window is the active window.
+  def window_state_demo
+    m = $gtk.args.inputs.mouse.has_focus ? 'Y' : 'N' # ternary operator (similar to if statement)
+    k = $gtk.args.inputs.keyboard.has_focus ? 'Y' : 'N'
+    outputs.labels << [460, 20, "mouse focus: #{m}   keyboard focus: #{k}", small_font]
   end
 
-  args.state.graphed_at = args.state.tick_count
-end
-
-def defaults_period_sine_wave_for
-  { frequency: 440, sample_rate: 48000 }
-end
-
-def sine_wave_for opts = { }
-  opts = defaults_period_sine_wave_for.merge opts
-  frequency   = opts[:frequency]
-  sample_rate = opts[:sample_rate]
-  period_size = (sample_rate.fdiv frequency).ceil
-  period_size.map_with_index do |i|
-    Math::sin((2.0 * Math::PI) / (sample_rate.to_f / frequency.to_f) * i)
-  end.to_a
-end
-
-def generate_audio_data sine_wave, sample_rate
-  sample_size = (sample_rate.fdiv (1000.fdiv 60)).ceil
-  copy_count  = (sample_size.fdiv sine_wave.length).ceil
-  sine_wave * copy_count
-end
+  #Sets values for the horizontal separator (divides demo sections)
+  def horizontal_seperator y, x, x2
+    [x, y, x2, y, 150, 150, 150]
+  end
 
-def defaults_queue_sine_wave
-  { frequency: 440, duration: 60, gain: 1.0, fade_out: false, queue_in: 0 }
-end
+  #Sets the values for the vertical separator (divides demo sections)
+  def vertical_seperator x, y, y2
+    [x, y, x, y2, 150, 150, 150]
+  end
 
-def queue_sine_wave args, opts = { }
-  opts        = defaults_queue_sine_wave.merge opts
-  decay_rate  = 0
-  decay_rate  = 1.fdiv(opts[:duration]) * opts[:gain] if opts[:fade_out]
-  frequency   = opts[:frequency]
-  sample_rate = 48000
+  # Outputs vertical and horizontal separators onto the screen to separate each demo section.
+  def render_seperators
+    outputs.lines << horizontal_seperator(505, grid.left, 445)
+    outputs.lines << horizontal_seperator(353, grid.left, 445)
+    outputs.lines << horizontal_seperator(264, grid.left, 445)
+    outputs.lines << horizontal_seperator(174, grid.left, 445)
 
-  audio_state = {
-    id:               (new_id! args),
-    frequency:        frequency,
-    sample_rate:      48000,
-    stop_at:          args.tick_count + opts[:queue_in] + opts[:duration],
-    gain:             opts[:gain].to_f,
-    queue_at:         args.state.tick_count + opts[:queue_in],
-    decay_rate:       decay_rate,
-    pitch:            1.0,
-    looping:          true,
-    paused:           false
-  }
+    outputs.lines << vertical_seperator(445, grid.top, grid.bottom)
 
-  sine_wave = sine_wave_for frequency: frequency, sample_rate: sample_rate
-  args.state.sine_waves[frequency] ||= sine_wave_for frequency: frequency, sample_rate: sample_rate
+    outputs.lines << horizontal_seperator(690, 445, 820)
+    outputs.lines << horizontal_seperator(426, 445, 820)
 
-  proc = lambda do
-    generate_audio_data args.state.sine_waves[frequency], sample_rate
+    outputs.lines << vertical_seperator(820, grid.top, grid.bottom)
   end
-
-  audio_state[:input] = [1, sample_rate, proc]
-  graph_sine_wave args, sine_wave, frequency
-  args.state.audio_queue << audio_state
-end
-
-def defaults_queue_bell
-  { frequency: 440, duration: 1.seconds, queue_in: 0 }
 end
 
-def queue_bell args, opts = {}
-  (bell_to_sine_waves (defaults_queue_bell.merge opts)).each { |b| queue_sine_wave args, b }
-end
+$tech_demo = TechDemo.new
 
-def bell_harmonics
-  [
-    { frequency_ratio: 0.5, duration_ratio: 1.00 },
-    { frequency_ratio: 1.0, duration_ratio: 0.80 },
-    { frequency_ratio: 2.0, duration_ratio: 0.60 },
-    { frequency_ratio: 3.0, duration_ratio: 0.40 },
-    { frequency_ratio: 4.2, duration_ratio: 0.25 },
-    { frequency_ratio: 5.4, duration_ratio: 0.20 },
-    { frequency_ratio: 6.8, duration_ratio: 0.15 }
-  ]
+def tick args
+  $tech_demo.inputs = args.inputs
+  $tech_demo.state = args.state
+  $tech_demo.grid = args.grid
+  $tech_demo.args = args
+  $tech_demo.outputs = args.render_target(:mini_map)
+  $tech_demo.tick
+  args.outputs.labels  << [830, 715, "Render target:", [-2, 0, 0, 0, 0, 255]]
+  args.outputs.sprites << [0, 0, 1280, 720, :mini_map]
+  args.outputs.sprites << [830, 300, 675, 379, :mini_map]
+  tick_instructions args, "Sample app shows all the rendering apis available."
 end
 
-def bell_to_sine_waves opts
-  bell_harmonics.map do |b|
-    {
-      frequency: opts[:frequency] * b[:frequency_ratio],
-      duration:  opts[:duration] * b[:duration_ratio],
-      queue_in:  opts[:queue_in],
-      gain:      (1.fdiv bell_harmonics.length),
-      fade_out:  true
-    }
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
   end
-end
-
-def defaults_frequency_for
-  { note: :a, octave: 5, sharp:  false, flat:   false }
-end
 
-def frequency_for opts = {}
-  opts = defaults_frequency_for.merge opts
-  octave_offset_multiplier  = opts[:octave] - 5
-  note = note_frequencies_octave_5[opts[:note]]
-  if octave_offset_multiplier < 0
-    note = note * 1 / (octave_offset_multiplier.abs + 1)
-  elsif octave_offset_multiplier > 0
-    note = note * (octave_offset_multiplier.abs + 1) / 1
-  end
-  note
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
 end
 
-def note_frequencies_octave_5
-  {
-    a: 440.0,
-    a_sharp: 466.16, b_flat: 466.16,
-    b: 493.88,
-    c: 523.25,
-    c_sharp: 554.37, d_flat: 587.33,
-    d: 587.33,
-    d_sharp: 622.25, e_flat: 659.25,
-    e: 659.25,
-    f: 698.25,
-    f_sharp: 739.99, g_flat: 739.99,
-    g: 783.99,
-    g_sharp: 830.61, a_flat: 830.61
-  }
-end
+
+Advanced Rendering - Render Primitive Hierarchies - main.rb
+# ./samples/07_advanced_rendering/04_render_primitive_hierarchies/app/main.rb
+=begin
 
-def new_id! args
-  args.state.audio_id ||= 0
-  args.state.audio_id  += 1
-end
+ APIs listing that haven't been encountered in previous sample apps:
 
-def button args, opts
-  button_def = opts.merge rect: (args.layout.rect (opts.merge w: 2, h: 1))
+ - Nested array: An array whose individual elements are also arrays; useful for
+   storing groups of similar data.  Also called multidimensional arrays.
 
-  button_def[:border] = button_def[:rect].merge r: 0, g: 0, b: 0
+   In this sample app, we see nested arrays being used in object definitions.
+   Notice the parameters for solids, listed below. Parameters 1-3 set the
+   definition for the rect, and parameter 4 sets the definition of the color.
 
-  font_size_enum = args.layout.font_relative_size_enum 0
-  label_offset_x = 4
-  label_offset_y = button_def[:rect].h.half + button_def[:rect].h.idiv(4)
+   Instead of having a solid definition that looks like this,
+   [X, Y, W, H, R, G, B]
+   we can separate it into two separate array definitions in one, like this
+   [[X, Y, W, H], [R, G, B]]
+   and both options work fine in defining our solid (or any object).
 
-  button_def[:label]  = button_def[:rect].merge text: opts[:text],
-                                                size_enum: font_size_enum,
-                                                x: button_def[:rect].x + label_offset_x,
-                                                y: button_def[:rect].y + label_offset_y
+ - Collections: Lists of data; useful for organizing large amounts of data.
+   One element of a collection could be an array (which itself contains many elements).
+   For example, a collection that stores two solid objects would look like this:
+   [
+    [100, 100, 50, 50, 0, 0, 0],
+    [100, 150, 50, 50, 255, 255, 255]
+   ]
+   If this collection was added to args.outputs.solids, two solids would be output
+   next to each other, one black and one white.
+   Nested arrays can be used in collections, as you will see in this sample app.
 
-  button_def
-end
+ Reminders:
 
-$gtk.reset
+ - args.outputs.solids: An array. The values generate a solid.
+   The parameters for a solid are
+   1. The position on the screen (x, y)
+   2. The width (w)
+   3. The height (h)
+   4. The color (r, g, b) (if a color is not assigned, the object's default color will be black)
+   NOTE: THE PARAMETERS ARE THE SAME FOR BORDERS!
 
-

-Input Basics - Keyboard - main.rb
-# ./samples/02_input_basics/01_keyboard/app/main.rb
-=begin
+   Here is an example of a (red) border or solid definition:
+   [100, 100, 400, 500, 255, 0, 0]
+   It will be a solid or border depending on if it is added to args.outputs.solids or args.outputs.borders.
+   For more information about solids and borders, go to mygame/documentation/03-solids-and-borders.md.
 
-APIs listing that haven't been encountered in a previous sample apps:
+ - args.outputs.sprites: An array. The values generate a sprite.
+   The parameters for sprites are
+   1. The position on the screen (x, y)
+   2. The width (w)
+   3. The height (h)
+   4. The image path (p)
 
-- args.inputs.keyboard.key_up.KEY: The value of the properties will be set
-  to the frame  that the key_up event occurred (the frame correlates
-  to args.state.tick_count). Otherwise the value will be nil. For a
-  full listing of keys, take a look at mygame/documentation/06-keyboard.md.
-- args.state.PROPERTY: The state property on args is a dynamic
-  structure. You can define ANY property here with ANY type of
-  arbitrary nesting. Properties defined on args.state will be retained
-  across frames. If you attempt access a property that doesn't exist
-  on args.state, it will simply return nil (no exception will be thrown).
+   Here is an example of a sprite definition:
+   [100, 100, 400, 500, 'sprites/dragonruby.png']
+   For more information about sprites, go to mygame/documentation/05-sprites.md.
 
 =end
 
-# Along with outputs, inputs are also an essential part of video game development
-# DragonRuby can take input from keyboards, mouse, and controllers.
-# This sample app will cover keyboard input.
-
-# args.inputs.keyboard.key_up.a will check to see if the a key has been pressed
-# This will work with the other keys as well
+# This code demonstrates the creation and output of objects like sprites, borders, and solids
+# If filled in, they are solids
+# If hollow, they are borders
+# If images, they are sprites
 
+# Solids are added to args.outputs.solids
+# Borders are added to args.outputs.borders
+# Sprites are added to args.outputs.sprites
 
+# The tick method runs 60 frames every second.
+# Your game is going to happen under this one function.
 def tick args
-  tick_instructions args, "Sample app shows how keyboard events are registered and accessed.", 360
-  # Notice how small_font accounts for all the remaining parameters
-  args.outputs.labels << [460, row_to_px(args, 0), "Current game time: #{args.state.tick_count}", small_font]
-  args.outputs.labels << [460, row_to_px(args, 2), "Keyboard input: args.inputs.keyboard.key_up.h", small_font]
-  args.outputs.labels << [460, row_to_px(args, 3), "Press \"h\" on the keyboard.", small_font]
-
-  # Input on a specifc key can be found through args.inputs.keyboard.key_up followed by the key
-  if args.inputs.keyboard.key_up.h
-    args.state.h_pressed_at = args.state.tick_count
-  end
-
-  # This code simplifies to if args.state.h_pressed_at has not been initialized, set it to false
-  args.state.h_pressed_at ||= false
-
-  if args.state.h_pressed_at
-    args.outputs.labels << [460, row_to_px(args, 4), "\"h\" was pressed at time: #{args.state.h_pressed_at}", small_font]
-  else
-    args.outputs.labels << [460, row_to_px(args, 4), "\"h\" has never been pressed.", small_font]
-  end
-
-  tick_help_text args
-end
-
-def small_font
-  # This method provides some values for the construction of labels
-  # Specifically, Size, Alignment, & RGBA
-  # This makes it so that custom parameters don't have to be repeatedly typed.
-  # Additionally "small_font" provides programmers with more information than some numbers
-  [-2, 0, 0, 0, 0, 255]
-end
-
-def row_to_px args, row_number
-  # This takes a row_number and converts it to pixels DragonRuby understands.
-  # Row 0 starts 5 units below the top of the grid
-  # Each row afterward is 20 units lower
-  args.grid.top.shift_down(5).shift_down(20 * row_number)
+  border_as_solid_and_solid_as_border args
+  sprite_as_border_or_solids args
+  collection_of_borders_and_solids args
+  collection_of_sprites args
 end
 
-# Don't worry about understanding the code within this method just yet.
-# This method shows you the help text within the game.
-def tick_help_text args
-  return unless args.state.h_pressed_at
+# Shows a border being output onto the screen as a border and a solid
+# Also shows how colors can be set
+def border_as_solid_and_solid_as_border args
+  border = [0, 0, 50, 50]
+  args.outputs.borders << border
+  args.outputs.solids  << border
 
-  args.state.key_value_history      ||= {}
-  args.state.key_down_value_history ||= {}
-  args.state.key_held_value_history ||= {}
-  args.state.key_up_value_history   ||= {}
+  # Red, green, blue saturations (last three parameters) can be any number between 0 and 255
+  border_with_color = [0, 100, 50, 50, 255, 0, 0]
+  args.outputs.borders << border_with_color
+  args.outputs.solids  << border_with_color
 
-  if (args.inputs.keyboard.key_down.truthy_keys.length > 0 ||
-      args.inputs.keyboard.key_held.truthy_keys.length > 0 ||
-      args.inputs.keyboard.key_up.truthy_keys.length > 0)
-    args.state.help_available = true
-    args.state.no_activity_debounce = nil
-  else
-    args.state.no_activity_debounce ||= 5.seconds
-    args.state.no_activity_debounce -= 1
-    if args.state.no_activity_debounce <= 0
-      args.state.help_available = false
-      args.state.key_value_history        = {}
-      args.state.key_down_value_history   = {}
-      args.state.key_held_value_history   = {}
-      args.state.key_up_value_history     = {}
-    end
-  end
+  border_with_nested_color = [0, 200, 50, 50, [0, 255, 0]] # nested color
+  args.outputs.borders << border_with_nested_color
+  args.outputs.solids  << border_with_nested_color
 
-  args.outputs.labels << [10, row_to_px(args, 6), "Advanced Help:", small_font]
+  border_with_nested_rect = [[0, 300, 50, 50], 0, 0, 255] # nested rect
+  args.outputs.borders << border_with_nested_rect
+  args.outputs.solids  << border_with_nested_rect
 
-  if !args.state.help_available
-    args.outputs.labels << [10, row_to_px(args, 7),  "Press a key and I'll show code to access the key and what value will be returned if you used the code.", small_font]
-    return
-  end
+  border_with_nested_color_and_rect = [[0, 400, 50, 50], [255, 0, 255]] # nested rect and color
+  args.outputs.borders << border_with_nested_color_and_rect
+  args.outputs.solids  << border_with_nested_color_and_rect
+end
 
-  args.outputs.labels << [10 , row_to_px(args, 7), "args.inputs.keyboard", small_font]
-  args.outputs.labels << [330, row_to_px(args, 7), "args.inputs.keyboard.key_down", small_font]
-  args.outputs.labels << [650, row_to_px(args, 7), "args.inputs.keyboard.key_held", small_font]
-  args.outputs.labels << [990, row_to_px(args, 7), "args.inputs.keyboard.key_up", small_font]
+# Shows a sprite output onto the screen as a sprite, border, and solid
+# Demonstrates that all three outputs appear differently on screen
+def sprite_as_border_or_solids args
+  sprite = [100, 0, 50, 50, 'sprites/ship.png']
+  args.outputs.sprites << sprite
 
-  fill_history args, :key_value_history,      :down_or_held, nil
-  fill_history args, :key_down_value_history, :down,        :key_down
-  fill_history args, :key_held_value_history, :held,        :key_held
-  fill_history args, :key_up_value_history,   :up,          :key_up
+  # Sprite_as_border variable has same parameters (excluding position) as above object,
+  # but will appear differently on screen because it is added to args.outputs.borders
+  sprite_as_border = [100, 100, 50, 50, 'sprites/ship.png']
+  args.outputs.borders << sprite_as_border
 
-  render_help_labels args, :key_value_history,      :down_or_held, nil,      10
-  render_help_labels args, :key_down_value_history, :down,        :key_down, 330
-  render_help_labels args, :key_held_value_history, :held,        :key_held, 650
-  render_help_labels args, :key_up_value_history,   :up,          :key_up,   990
+  # Sprite_as_solid variable has same parameters (excluding position) as above object,
+  # but will appear differently on screen because it is added to args.outputs.solids
+  sprite_as_solid = [100, 200, 50, 50, 'sprites/ship.png']
+  args.outputs.solids << sprite_as_solid
 end
 
-def fill_history args, history_key, state_key, keyboard_method
-  fill_single_history args, history_key, state_key, keyboard_method, :raw_key
-  fill_single_history args, history_key, state_key, keyboard_method, :char
-  args.inputs.keyboard.keys[state_key].each do |key_name|
-    fill_single_history args, history_key, state_key, keyboard_method, key_name
-  end
-end
+# Holds and outputs a collection of borders and a collection of solids
+# Collections are created by using arrays to hold parameters of each individual object
+def collection_of_borders_and_solids args
+  collection_borders = [
+    [
+      [200,  0, 50, 50],                    # black border
+      [200,  100, 50, 50, 255, 0, 0],       # red border
+      [200,  200, 50, 50, [0, 255, 0]],     # nested color
+    ],
+    [[200, 300, 50, 50], 0, 0, 255],        # nested rect
+    [[200, 400, 50, 50], [255, 0, 255]]     # nested rect and nested color
+  ]
 
-def fill_single_history args, history_key, state_key, keyboard_method, key_name
-  current_value = args.inputs.keyboard.send(key_name)
-  if keyboard_method
-    current_value = args.inputs.keyboard.send(keyboard_method).send(key_name)
-  end
-  args.state.as_hash[history_key][key_name] ||= []
-  args.state.as_hash[history_key][key_name] << current_value
-  args.state.as_hash[history_key][key_name] = args.state.as_hash[history_key][key_name].reverse.uniq.take(3).reverse
-end
+  args.outputs.borders << collection_borders
 
-def render_help_labels args, history_key, state_key, keyboard_method, x
-  idx = 8
-  args.outputs.labels << args.state
-                           .as_hash[history_key]
-                           .keys
-                           .reverse
-                           .map
-                           .with_index do |k, i|
-    v = args.state.as_hash[history_key][k]
-    current_value = args.inputs.keyboard.send(k)
-    if keyboard_method
-      current_value = args.inputs.keyboard.send(keyboard_method).send(k)
-    end
-    idx += 2
+  collection_solids = [
     [
-      [x, row_to_px(args, idx - 2),
-       "    .#{k} is #{current_value || "nil"}",
-       small_font],
-      [x, row_to_px(args, idx - 1),
-       "       was #{v}",
-       small_font]
-    ]
-  end
+      [[300, 300, 50, 50], 0, 0, 255],      # nested rect
+      [[300, 400, 50, 50], [255, 0, 255]]   # nested rect and nested color
+    ],
+    [300,  0, 50, 50],
+    [300,  100, 50, 50, 255, 0, 0],
+    [300,  200, 50, 50, [0, 255, 0]],       # nested color
+  ]
+
+  args.outputs.solids << collection_solids
 end
 
+# Holds and outputs a collection of sprites by adding it to args.outputs.sprites
+# Also outputs a collection with same parameters (excluding position) by adding
+# it to args.outputs.solids and another to args.outputs.borders
+def collection_of_sprites args
+  sprites_collection = [
+    [
+      [400, 0, 50, 50, 'sprites/ship.png'],
+      [400, 100, 50, 50, 'sprites/ship.png'],
+    ],
+    [400, 200, 50, 50, 'sprites/ship.png']
+  ]
+
+  args.outputs.sprites << sprites_collection
 
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
-  end
+  args.outputs.solids << [
+    [500, 0, 50, 50, 'sprites/ship.png'],
+    [500, 100, 50, 50, 'sprites/ship.png'],
+    [[[500, 200, 50, 50, 'sprites/ship.png']]]
+  ]
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+  args.outputs.borders << [
+    [
+      [600, 0, 50, 50, 'sprites/ship.png'],
+      [600, 100, 50, 50, 'sprites/ship.png'],
+    ],
+    [600, 200, 50, 50, 'sprites/ship.png']
+  ]
 end
 
-
-Input Basics - Mouse - main.rb
-# ./samples/02_input_basics/02_mouse/app/main.rb
+
+Advanced Rendering - Render Primitives As Hash - main.rb
+# ./samples/07_advanced_rendering/05_render_primitives_as_hash/app/main.rb
 =begin
 
-APIs that haven't been encountered in a previous sample apps:
+ Reminders:
 
-- args.inputs.mouse.click: This property will be set if the mouse was clicked.
-- args.inputs.mouse.click.point.(x|y): The x and y location of the mouse.
-- args.inputs.mouse.click.point.created_at: The frame the mouse click occurred in.
-- args.inputs.mouse.click.point.created_at_elapsed: How many frames have passed
-  since the click event.
+ - Hashes: Collection of unique keys and their corresponding values. The value can be found
+   using their keys.
 
-Reminder:
+   For example, if we have a "numbers" hash that stores numbers in English as the
+   key and numbers in Spanish as the value, we'd have a hash that looks like this...
+   numbers = { "one" => "uno", "two" => "dos", "three" => "tres" }
+   and on it goes.
 
-- args.state.PROPERTY: The state property on args is a dynamic
-  structure. You can define ANY property here with ANY type of
-  arbitrary nesting. Properties defined on args.state will be retained
-  across frames. If you attempt access a property that doesn't exist
-  on args.state, it will simply return nil (no exception will be thrown).
+   Now if we wanted to find the corresponding value of the "one" key, we could say
+   puts numbers["one"]
+   which would print "uno" to the console.
 
-=end
+ - args.outputs.sprites: An array. The values generate a sprite.
+   The parameters are [X, Y, WIDTH, HEIGHT, PATH, ANGLE, ALPHA, RED, GREEN, BLUE]
+   For more information about sprites, go to mygame/documentation/05-sprites.md.
 
-# This code demonstrates DragonRuby mouse input
+ - args.outputs.labels: An array. The values generate a label.
+   The parameters are [X, Y, TEXT, SIZE, ALIGNMENT, RED, GREEN, BLUE, ALPHA, FONT STYLE]
+   For more information about labels, go to mygame/documentation/02-labels.md.
 
-# To see if the a mouse click occurred
-# Use args.inputs.mouse.click
-# Which returns a boolean
+ - args.outputs.solids: An array. The values generate a solid.
+   The parameters are [X, Y, WIDTH, HEIGHT, RED, GREEN, BLUE, ALPHA]
+   For more information about solids, go to mygame/documentation/03-solids-and-borders.md.
 
-# To see where a mouse click occurred
-# Use args.inputs.mouse.click.point.x AND
-# args.inputs.mouse.click.point.y
+ - args.outputs.borders: An array. The values generate a border.
+   The parameters are the same as a solid.
+   For more information about borders, go to mygame/documentation/03-solids-and-borders.md.
 
-# To see which frame the click occurred
-# Use args.inputs.mouse.click.created_at
+ - args.outputs.lines: An array. The values generate a line.
+   The parameters are [X1, Y1, X2, Y2, RED, GREEN, BLUE]
+   For more information about labels, go to mygame/documentation/02-labels.md.
 
-# To see how many frames its been since the click occurred
-# Use args.inputs.mouse.click.creat_at_elapsed
+=end
 
-# Saving the click in args.state can be quite useful
+# This sample app demonstrates how hashes can be used to output different kinds of objects.
 
 def tick args
-  tick_instructions args, "Sample app shows how mouse events are registered and how to measure elapsed time."
-  x = 460
-
-  args.outputs.labels << small_label(args, x, 11, "Mouse input: args.inputs.mouse")
+  args.state.angle ||= 0 # initializes angle to 0
+  args.state.angle  += 1 # increments angle by 1 every frame (60 times a second)
 
-  if args.inputs.mouse.click
-    args.state.last_mouse_click = args.inputs.mouse.click
-  end
+  # Outputs sprite using a hash
+  args.outputs.sprites << {
+    x: 30,                          # sprite position
+    y: 550,
+    w: 128,                         # sprite size
+    h: 101,
+    path: "dragonruby.png",         # image path
+    angle: args.state.angle,        # angle
+    a: 255,                         # alpha (transparency)
+    r: 255,                         # color saturation
+    g: 255,
+    b: 255,
+    tile_x:  0,                     # sprite sub division/tile
+    tile_y:  0,
+    tile_w: -1,
+    tile_h: -1,
+    flip_vertically: false,         # don't flip sprite
+    flip_horizontally: false,
+    angle_anchor_x: 0.5,            # rotation center set to middle
+    angle_anchor_y: 0.5
+  }
 
-  if args.state.last_mouse_click
-    click = args.state.last_mouse_click
-    args.outputs.labels << small_label(args, x, 12, "Mouse click happened at: #{click.created_at}")
-    args.outputs.labels << small_label(args, x, 13, "Mouse clicked #{click.created_at_elapsed} ticks ago")
-    args.outputs.labels << small_label(args, x, 14, "Mouse click location: #{click.point.x}, #{click.point.y}")
-  else
-    args.outputs.labels << small_label(args, x, 12, "Mouse click has not occurred yet.")
-    args.outputs.labels << small_label(args, x, 13, "Please click mouse.")
-  end
-end
+  # Outputs label using a hash
+  args.outputs.labels << {
+    x:              200,                 # label position
+    y:              550,
+    text:           "dragonruby",        # label text
+    size_enum:      2,
+    alignment_enum: 1,
+    r:              155,                 # color saturation
+    g:              50,
+    b:              50,
+    a:              255,                 # transparency
+    font:           "fonts/manaspc.ttf"  # font style; without mentioned file, label won't output correctly
+  }
 
-def small_label args, x, row, message
-  # This method effectively combines the row_to_px and small_font methods
-  # It changes the given row value to a DragonRuby pixel value
-  # and adds the customization parameters
-  [x, row_to_px(args, row), message, small_font]
-end
+  # Outputs solid using a hash
+  # [X, Y, WIDTH, HEIGHT, RED, GREEN, BLUE, ALPHA]
+  args.outputs.solids << {
+    x: 400,                         # position
+    y: 550,
+    w: 160,                         # size
+    h:  90,
+    r: 120,                         # color saturation
+    g:  50,
+    b:  50,
+    a: 255                          # transparency
+  }
 
-def small_font
-  [-2, 0, 0, 0, 0, 255]
-end
+  # Outputs border using a hash
+  # Same parameters as a solid
+  args.outputs.borders << {
+    x: 600,
+    y: 550,
+    w: 160,
+    h:  90,
+    r: 120,
+    g:  50,
+    b:  50,
+    a: 255
+  }
 
-def row_to_px args, row_number
-  args.grid.top.shift_down(5).shift_down(20 * row_number)
-end
+  # Outputs line using a hash
+  args.outputs.lines << {
+    x:  900,                        # starting position
+    y:  550,
+    x2: 1200,                       # ending position
+    y2: 550,
+    r:  120,                        # color saturation
+    g:   50,
+    b:   50,
+    a:  255                         # transparency
+  }
 
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
-  end
+  # Outputs sprite as a primitive using a hash
+  args.outputs.primitives << {
+    x: 30,                          # position
+    y: 200,
+    w: 128,                         # size
+    h: 101,
+    path: "dragonruby.png",         # image path
+    angle: args.state.angle,        # angle
+    a: 255,                         # transparency
+    r: 255,                         # color saturation
+    g: 255,
+    b: 255,
+    tile_x:  0,                     # sprite sub division/tile
+    tile_y:  0,
+    tile_w: -1,
+    tile_h: -1,
+    flip_vertically: false,         # don't flip
+    flip_horizontally: false,
+    angle_anchor_x: 0.5,            # rotation center set to middle
+    angle_anchor_y: 0.5
+  }.sprite
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
-end
+  # Outputs label as primitive using a hash
+  args.outputs.primitives << {
+    x:         200,                 # position
+    y:         200,
+    text:      "dragonruby",        # text
+    size:      2,
+    alignment: 1,
+    r:         155,                 # color saturation
+    g:         50,
+    b:         50,
+    a:         255,                 # transparency
+    font:      "fonts/manaspc.ttf"  # font style
+  }.label
 
-

-Input Basics - Mouse Point To Rect - main.rb
-# ./samples/02_input_basics/03_mouse_point_to_rect/app/main.rb
-=begin
+  # Outputs solid as primitive using a hash
+  args.outputs.primitives << {
+    x: 400,                         # position
+    y: 200,
+    w: 160,                         # size
+    h:  90,
+    r: 120,                         # color saturation
+    g:  50,
+    b:  50,
+    a: 255                          # transparency
+  }.solid
 
-APIs that haven't been encountered in a previous sample apps:
+  # Outputs border as primitive using a hash
+  # Same parameters as solid
+  args.outputs.primitives << {
+    x: 600,                         # position
+    y: 200,
+    w: 160,                         # size
+    h:  90,
+    r: 120,                         # color saturation
+    g:  50,
+    b:  50,
+    a: 255                          # transparency
+  }.border
 
-- args.outputus.borders: An array. Values in this array will be rendered as
-  unfilled rectangles on the screen.
-- ARRAY#inside_rect?: An array with at least two values is considered a point. An array
-  with at least four values is considered a rect. The inside_rect? function returns true
-  or false depending on if the point is inside the rect.
+  # Outputs line as primitive using a hash
+  args.outputs.primitives << {
+    x:  900,                        # starting position
+    y:  200,
+    x2: 1200,                       # ending position
+    y2: 200,
+    r:  120,                        # color saturation
+    g:   50,
+    b:   50,
+    a:  255                         # transparency
+  }.line
+end
 
-  ```
-  # Point:  x: 100, y: 100
-  # Rect:   x: 0, y: 0, w: 500, h: 500
-  # Result: true
+
+Advanced Rendering - Pixel Arrays - main.rb
+# ./samples/07_advanced_rendering/06_pixel_arrays/app/main.rb
+$gtk.reset
 
-  [100, 100].inside_rect? [0, 0, 500, 500]
-  ```
+def tick args
+  args.state.posinc ||= 1
+  args.state.pos ||= 0
+  args.state.rotation ||= 0
 
-  ```
-  # Point:  x: 100, y: 100
-  # Rect:   x: 300, y: 300, w: 100, h: 100
-  # Result: false
+  dimension = 10  # keep it small and let the GPU scale it when rendering the sprite.
 
-  [100, 100].inside_rect? [300, 300, 100, 100]
-  ```
+  # Set up our "scanner" pixel array and fill it with black pixels.
+  args.pixel_array(:scanner).width = dimension
+  args.pixel_array(:scanner).height = dimension
+  args.pixel_array(:scanner).pixels.fill(0xFF000000, 0, dimension * dimension)  # black, full alpha
 
-- args.inputs.mouse.click.point.created_at: The frame the mouse click occurred in.
-- args.inputs.mouse.click.point.created_at_elapsed: How many frames have passed
-  since the click event.
+  # Draw a green line that bounces up and down the sprite.
+  args.pixel_array(:scanner).pixels.fill(0xFF00FF00, dimension * args.state.pos, dimension)  # green, full alpha
 
-=end
+  # Adjust position for next frame.
+  args.state.pos += args.state.posinc
+  if args.state.posinc > 0 && args.state.pos >= dimension
+    args.state.posinc = -1
+    args.state.pos = dimension - 1
+  elsif args.state.posinc < 0 && args.state.pos < 0
+    args.state.posinc = 1
+    args.state.pos = 1
+  end
 
-# To determine whether a point is in a rect
-# Use point.inside_rect? rect
+  # New/changed pixel arrays get uploaded to the GPU before we render
+  #  anything. At that point, they can be scaled, rotated, and otherwise
+  #  used like any other sprite.
+  w = 100
+  h = 100
+  x = (1280 - w) / 2
+  y = (720 - h) / 2
+  args.outputs.background_color = [64, 0, 128]
+  args.outputs.primitives << [x, y, w, h, :scanner, args.state.rotation].sprite
+  args.state.rotation += 1
 
-# This is useful to determine if a click occurred in a rect
+  args.outputs.primitives << args.gtk.current_framerate_primitives
+end
 
-def tick args
-  tick_instructions args, "Sample app shows how to determing if a click happened inside a rectangle."
 
-  x = 460
+
+Advanced Rendering - Splitscreen Camera - main.rb
+# ./samples/07_advanced_rendering/07_splitscreen_camera/app/main.rb
+class CameraMovement
+  attr_accessor :state, :inputs, :outputs, :grid
 
-  args.outputs.labels << small_label(args, x, 15, "Click inside the blue box maybe ---->")
+  #==============================================================================================
+  #Serialize
+  def serialize
+    {state: state, inputs: inputs, outputs: outputs, grid: grid }
+  end
 
-  box = [785, 370, 50, 50, 0, 0, 170]
-  args.outputs.borders << box
+  def inspect
+    serialize.to_s
+  end
 
-  # Saves the most recent click into args.state
-  # Unlike the other components of args,
-  # args.state does not reset every tick.
-  if args.inputs.mouse.click
-    args.state.last_mouse_click = args.inputs.mouse.click
+  def to_s
+    serialize.to_s
   end
 
-  if args.state.last_mouse_click
-    if args.state.last_mouse_click.point.inside_rect? box
-      args.outputs.labels << small_label(args, x, 16, "Mouse click happened *inside* the box.")
-    else
-      args.outputs.labels << small_label(args, x, 16, "Mouse click happened *outside* the box.")
-    end
-  else
-    args.outputs.labels << small_label(args, x, 16, "Mouse click has not occurred yet.")
+  #==============================================================================================
+  #Tick
+  def tick
+    defaults
+    calc
+    render
+    input
   end
-end
 
-def small_label args, x, row, message
-  [x, row_to_px(args, row), message, small_font]
-end
+  #==============================================================================================
+  #Default functions
+  def defaults
+    outputs[:scene].background_color = [0,0,0]
+    state.trauma ||= 0.0
+    state.trauma_power ||= 2
+    state.player_cyan ||= new_player_cyan
+    state.player_magenta ||= new_player_magenta
+    state.camera_magenta ||= new_camera_magenta
+    state.camera_cyan ||= new_camera_cyan
+    state.camera_center ||= new_camera_center
+    state.room ||= new_room
+  end
 
-def small_font
-  [-2, 0, 0, 0, 0, 255]
-end
+  def default_player x, y, w, h, sprite_path
+    state.new_entity(:player,
+                     { x: x,
+                       y: y,
+                       dy: 0,
+                       dx: 0,
+                       w: w,
+                       h: h,
+                       damage: 0,
+                       dead: false,
+                       orientation: "down",
+                       max_alpha: 255,
+                       sprite_path: sprite_path})
+  end
 
-def row_to_px args, row_number
-  args.grid.top.shift_down(5).shift_down(20 * row_number)
-end
+  def default_floor_tile x, y, w, h, sprite_path
+    state.new_entity(:room,
+                     { x: x,
+                       y: y,
+                       w: w,
+                       h: h,
+                       sprite_path: sprite_path})
+  end
 
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
+  def default_camera x, y, w, h
+    state.new_entity(:camera,
+                     { x: x,
+                       y: y,
+                       dx: 0,
+                       dy: 0,
+                       w: w,
+                       h: h})
   end
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
-end
+  def new_player_cyan
+    default_player(0, 0, 64, 64,
+                   "sprites/player/player_#{state.player_cyan.orientation}_standing.png")
+  end
 
-

-Input Basics - Mouse Rect To Rect - main.rb
-# ./samples/02_input_basics/04_mouse_rect_to_rect/app/main.rb
-=begin
+  def new_player_magenta
+    default_player(64, 0, 64, 64,
+                   "sprites/player/player_#{state.player_magenta.orientation}_standing.png")
+  end
 
-APIs that haven't been encountered in a previous sample apps:
+  def new_camera_magenta
+    default_camera(0,0,720,720)
+  end
 
-- args.outputs.borders: An array. Values in this array will be rendered as
-  unfilled rectangles on the screen.
-- ARRAY#intersect_rect?: An array with at least four values is
-  considered a rect. The intersect_rect? function returns true
-  or false depending on if the two rectangles intersect.
+  def new_camera_cyan
+    default_camera(0,0,720,720)
+  end
 
-  ```
-  # Rect One: x: 100, y: 100, w: 100, h: 100
-  # Rect Two: x: 0, y: 0, w: 500, h: 500
-  # Result:   true
+  def new_camera_center
+    default_camera(0,0,1280,720)
+  end
 
-  [100, 100, 100, 100].intersect_rect? [0, 0, 500, 500]
-  ```
+  def new_room
+    default_floor_tile(0,0,1024,1024,'sprites/rooms/camera_room.png')
+  end
 
-  ```
-  # Rect One: x: 100, y: 100, w: 10, h: 10
-  # Rect Two: x: 500, y: 500, w: 10, h: 10
-  # Result:   false
+  #==============================================================================================
+  #Calculation functions
+  def calc
+    calc_camera_magenta
+    calc_camera_cyan
+    calc_camera_center
+    calc_player_cyan
+    calc_player_magenta
+    calc_trauma_decay
+  end
 
-  [100, 100, 10, 10].intersect_rect? [500, 500, 10, 10]
-  ```
+  def center_camera_tolerance
+    return Math.sqrt(((state.player_magenta.x - state.player_cyan.x) ** 2) +
+              ((state.player_magenta.y - state.player_cyan.y) ** 2)) > 640
+  end
 
-=end
+  def calc_player_cyan
+    state.player_cyan.x += state.player_cyan.dx
+    state.player_cyan.y += state.player_cyan.dy
+  end
 
-# Similarly, whether rects intersect can be found through
-# rect1.intersect_rect? rect2
+  def calc_player_magenta
+    state.player_magenta.x += state.player_magenta.dx
+    state.player_magenta.y += state.player_magenta.dy
+  end
 
-def tick args
-  tick_instructions args, "Sample app shows how to determine if two rectangles intersect."
-  x = 460
+  def calc_camera_center
+    timeScale = 1
+    midX = (state.player_magenta.x + state.player_cyan.x)/2
+    midY = (state.player_magenta.y + state.player_cyan.y)/2
+    targetX = midX - state.camera_center.w/2
+    targetY = midY - state.camera_center.h/2
+    state.camera_center.x += (targetX - state.camera_center.x) * 0.1 * timeScale
+    state.camera_center.y += (targetY - state.camera_center.y) * 0.1 * timeScale
+  end
 
-  args.outputs.labels << small_label(args, x, 3, "Click anywhere on the screen")
-  # red_box = [460, 250, 355, 90, 170, 0, 0]
-  # args.outputs.borders << red_box
 
-  # args.state.box_collision_one and args.state.box_collision_two
-  # Are given values of a solid when they should be rendered
-  # They are stored in game so that they do not get reset every tick
-  if args.inputs.mouse.click
-    if !args.state.box_collision_one
-      args.state.box_collision_one = [args.inputs.mouse.click.point.x - 25, args.inputs.mouse.click.point.y - 25, 125, 125, 180, 0,   0, 180]
-    elsif !args.state.box_collision_two
-      args.state.box_collision_two = [args.inputs.mouse.click.point.x - 25, args.inputs.mouse.click.point.y - 25, 125, 125,   0, 0, 180, 180]
-    else
-      args.state.box_collision_one = nil
-      args.state.box_collision_two = nil
+  def calc_camera_magenta
+    timeScale = 1
+    targetX = state.player_magenta.x + state.player_magenta.w - state.camera_magenta.w/2
+    targetY = state.player_magenta.y + state.player_magenta.h - state.camera_magenta.h/2
+    state.camera_magenta.x += (targetX - state.camera_magenta.x) * 0.1 * timeScale
+    state.camera_magenta.y += (targetY - state.camera_magenta.y) * 0.1 * timeScale
+  end
+
+  def calc_camera_cyan
+    timeScale = 1
+    targetX = state.player_cyan.x + state.player_cyan.w - state.camera_cyan.w/2
+    targetY = state.player_cyan.y + state.player_cyan.h - state.camera_cyan.h/2
+    state.camera_cyan.x += (targetX - state.camera_cyan.x) * 0.1 * timeScale
+    state.camera_cyan.y += (targetY - state.camera_cyan.y) * 0.1 * timeScale
+  end
+
+  def calc_player_quadrant angle
+    if angle < 45 and angle > -45 and state.player_cyan.x < state.player_magenta.x
+      return 1
+    elsif angle < 45 and angle > -45 and state.player_cyan.x > state.player_magenta.x
+      return 3
+    elsif (angle > 45 or angle < -45) and state.player_cyan.y < state.player_magenta.y
+      return 2
+    elsif (angle > 45 or angle < -45) and state.player_cyan.y > state.player_magenta.y
+      return 4
     end
   end
 
-  if args.state.box_collision_one
-    args.outputs.solids << args.state.box_collision_one
+  def calc_camera_shake
+    state.trauma
   end
 
-  if args.state.box_collision_two
-    args.outputs.solids << args.state.box_collision_two
+  def calc_trauma_decay
+    state.trauma = state.trauma * 0.9
   end
 
-  if args.state.box_collision_one && args.state.box_collision_two
-    if args.state.box_collision_one.intersect_rect? args.state.box_collision_two
-      args.outputs.labels << small_label(args, x, 4, 'The boxes intersect.')
+  def calc_random_float_range(min, max)
+    rand * (max-min) + min
+  end
+
+  #==============================================================================================
+  #Render Functions
+  def render
+    render_floor
+    render_player_cyan
+    render_player_magenta
+    if center_camera_tolerance
+      render_split_camera_scene
     else
-      args.outputs.labels << small_label(args, x, 4, 'The boxes do not intersect.')
+      render_camera_center_scene
     end
-  else
-    args.outputs.labels << small_label(args, x, 4, '--')
   end
-end
 
-def small_label args, x, row, message
-  [x, row_to_px(args, row), message, small_font]
-end
-
-def small_font
-  [-2, 0, 0, 0, 0, 255]
-end
+  def render_player_cyan
+    outputs[:scene].sprites << {x: state.player_cyan.x,
+                                y: state.player_cyan.y,
+                                w: state.player_cyan.w,
+                                h: state.player_cyan.h,
+                                path: "sprites/player/player_#{state.player_cyan.orientation}_standing.png",
+                                r: 0,
+                                g: 255,
+                                b: 255}
+  end
 
-def row_to_px args, row_number
-  args.grid.top.shift_down(5).shift_down(20 * row_number)
-end
+  def render_player_magenta
+    outputs[:scene].sprites << {x: state.player_magenta.x,
+                                y: state.player_magenta.y,
+                                w: state.player_magenta.w,
+                                h: state.player_magenta.h,
+                                path: "sprites/player/player_#{state.player_magenta.orientation}_standing.png",
+                                r: 255,
+                                g: 0,
+                                b: 255}
+  end
 
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
+  def render_floor
+    outputs[:scene].sprites << [state.room.x, state.room.y,
+                                state.room.w, state.room.h,
+                                state.room.sprite_path]
   end
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
-end
+  def render_camera_center_scene
+    zoomFactor = 1
+    outputs[:scene].width = state.room.w
+    outputs[:scene].height = state.room.h
 
-
-Input Basics - Controller - main.rb
-# ./samples/02_input_basics/05_controller/app/main.rb
-=begin
+    maxAngle = 10.0
+    maxOffset = 20.0
+    angle = maxAngle * calc_camera_shake * calc_random_float_range(-1,1)
+    offsetX = 32 - (maxOffset * calc_camera_shake * calc_random_float_range(-1,1))
+    offsetY = 32 - (maxOffset * calc_camera_shake * calc_random_float_range(-1,1))
 
- APIs listing that haven't been encountered in previous sample apps:
+    outputs.sprites << {x: (-state.camera_center.x - offsetX)/zoomFactor,
+                        y: (-state.camera_center.y - offsetY)/zoomFactor,
+                        w: outputs[:scene].width/zoomFactor,
+                        h: outputs[:scene].height/zoomFactor,
+                        path: :scene,
+                        angle: angle,
+                        source_w: -1,
+                        source_h: -1}
+    outputs.labels << [128,64,"#{state.trauma.round(1)}",8,2,255,0,255,255]
+  end
 
- - args.inputs.controller_one.key_held.KEY: Will check to see if a specific key
-   is being held down on the controller.
-   If there is more than one controller being used, they can be differentiated by
-   using names like controller_one and controller_two.
+  def render_split_camera_scene
+     outputs[:scene].width = state.room.w
+     outputs[:scene].height = state.room.h
+     render_camera_magenta_scene
+     render_camera_cyan_scene
 
-   For a full listing of buttons, take a look at mygame/documentation/08-controllers.md.
+     angle = Math.atan((state.player_magenta.y - state.player_cyan.y)/(state.player_magenta.x- state.player_cyan.x)) * 180/Math::PI
+     output_split_camera angle
 
- Reminder:
+  end
 
- - args.state.PROPERTY: The state property on args is a dynamic
-   structure. You can define ANY property here with ANY type of
-   arbitrary nesting. Properties defined on args.state will be retained
-   across frames. If you attempt to access a property that doesn't exist
-   on args.state, it will simply return nil (no exception will be thrown).
+  def render_camera_magenta_scene
+     zoomFactor = 1
+     offsetX = 32
+     offsetY = 32
 
-   In this sample app, args.state.BUTTONS is an array that stores the buttons of the controller.
-   The parameters of a button are:
-   1. the position (x, y)
-   2. the input key held on the controller
-   3. the text or name of the button
+     outputs[:scene_magenta].sprites << {x: (-state.camera_magenta.x*2),
+                                         y: (-state.camera_magenta.y),
+                                         w: outputs[:scene].width*2,
+                                         h: outputs[:scene].height,
+                                         path: :scene}
 
-=end
+  end
 
-# This sample app provides a visual demonstration of a standard controller, including
-# the placement and function of all buttons.
+  def render_camera_cyan_scene
+    zoomFactor = 1
+    offsetX = 32
+    offsetY = 32
+    outputs[:scene_cyan].sprites << {x: (-state.camera_cyan.x*2),
+                                     y: (-state.camera_cyan.y),
+                                     w: outputs[:scene].width*2,
+                                     h: outputs[:scene].height,
+                                     path: :scene}
+  end
 
-class ControllerDemo
-  attr_accessor :inputs, :state, :outputs
+  def output_split_camera angle
+    #TODO: Clean this up!
+    quadrant = calc_player_quadrant angle
+    outputs.labels << [128,64,"#{quadrant}",8,2,255,0,255,255]
+    if quadrant == 1
+      set_camera_attributes(w: 640, h: 720, m_x: 640, m_y: 0, c_x: 0, c_y: 0)
 
-  # Calls the methods necessary for the app to run successfully.
-  def tick
-    process_inputs
-    render
-  end
+    elsif quadrant == 2
+      set_camera_attributes(w: 1280, h: 360, m_x: 0, m_y: 360, c_x: 0, c_y: 0)
 
-  # Starts with an empty collection of buttons.
-  # Adds buttons that are on the controller to the collection.
-  def process_inputs
-    state.buttons = []
+    elsif quadrant == 3
+      set_camera_attributes(w: 640, h: 720, m_x: 0, m_y: 0, c_x: 640, c_y: 0)
 
-    state.buttons << [100, 500, inputs.controller_one.key_held.l1, "L1"]
-    state.buttons << [100, 600, inputs.controller_one.key_held.l2, "L2"]
+    elsif quadrant == 4
+      set_camera_attributes(w: 1280, h: 360, m_x: 0, m_y: 0, c_x: 0, c_y: 360)
 
-    state.buttons << [1100, 500, inputs.controller_one.key_held.r1, "R1"]
-    state.buttons << [1100, 600, inputs.controller_one.key_held.r2, "R2"]
+    end
+  end
 
-    state.buttons << [540, 450, inputs.controller_one.key_held.select, "Select"]
-    state.buttons << [660, 450, inputs.controller_one.key_held.start, "Start"]
+  def set_camera_attributes(w: 0, h: 0, m_x: 0, m_y: 0, c_x: 0, c_y: 0)
+    state.camera_cyan.w = w + 64
+    state.camera_cyan.h = h + 64
+    outputs[:scene_cyan].width = (w) * 2
+    outputs[:scene_cyan].height = h
 
-    state.buttons << [200, 300, inputs.controller_one.key_held.left, "Left"]
-    state.buttons << [300, 400, inputs.controller_one.key_held.up, "Up"]
-    state.buttons << [400, 300, inputs.controller_one.key_held.right, "Right"]
-    state.buttons << [300, 200, inputs.controller_one.key_held.down, "Down"]
+    state.camera_magenta.w = w + 64
+    state.camera_magenta.h = h + 64
+    outputs[:scene_magenta].width = (w) * 2
+    outputs[:scene_magenta].height = h
+    outputs.sprites << {x: m_x,
+                        y: m_y,
+                        w: w,
+                        h: h,
+                        path: :scene_magenta}
+    outputs.sprites << {x: c_x,
+                        y: c_y,
+                        w: w,
+                        h: h,
+                        path: :scene_cyan}
+  end
 
-    state.buttons << [800, 300, inputs.controller_one.key_held.x, "X"]
-    state.buttons << [900, 400, inputs.controller_one.key_held.y, "Y"]
-    state.buttons << [1000, 300, inputs.controller_one.key_held.a, "A"]
-    state.buttons << [900, 200, inputs.controller_one.key_held.b, "B"]
+  def add_trauma amount
+    state.trauma = [state.trauma + amount, 1.0].min
+  end
 
-    state.buttons << [450 + inputs.controller_one.left_analog_x_perc * 100,
-                      100 + inputs.controller_one.left_analog_y_perc * 100,
-                      inputs.controller_one.key_held.l3,
-                      "L3"]
+  def remove_trauma amount
+    state.trauma = [state.trauma - amount, 0.0].max
+  end
+  #==============================================================================================
+  #Input functions
+  def input
+    input_move_cyan
+    input_move_magenta
 
-    state.buttons << [750 + inputs.controller_one.right_analog_x_perc * 100,
-                      100 + inputs.controller_one.right_analog_y_perc * 100,
-                      inputs.controller_one.key_held.r3,
-                      "R3"]
+    if inputs.keyboard.key_down.t
+      add_trauma(0.5)
+    elsif inputs.keyboard.key_down.y
+      remove_trauma(0.1)
+    end
   end
 
-  # Gives each button a square shape.
-  # If the button is being pressed or held (which means it is considered active),
-  # the square is filled in. Otherwise, the button simply has a border.
-  def render
-    state.buttons.each do |x, y, active, text|
-      rect = [x, y, 75, 75]
+  def input_move_cyan
+    if inputs.keyboard.key_held.up
+      state.player_cyan.dy = 5
+      state.player_cyan.orientation = "up"
+    elsif inputs.keyboard.key_held.down
+      state.player_cyan.dy = -5
+      state.player_cyan.orientation = "down"
+    else
+      state.player_cyan.dy *= 0.8
+    end
+    if inputs.keyboard.key_held.left
+      state.player_cyan.dx = -5
+      state.player_cyan.orientation = "left"
+    elsif inputs.keyboard.key_held.right
+      state.player_cyan.dx = 5
+      state.player_cyan.orientation = "right"
+    else
+      state.player_cyan.dx *= 0.8
+    end
 
-      if active # if button is pressed
-        outputs.solids << rect # rect is output as solid (filled in)
-      else
-        outputs.borders << rect # otherwise, output as border
-      end
+    outputs.labels << [128,512,"#{state.player_cyan.x.round()}",8,2,0,255,255,255]
+    outputs.labels << [128,480,"#{state.player_cyan.y.round()}",8,2,0,255,255,255]
+  end
 
-      # Outputs the text of each button using labels.
-      outputs.labels << [x, y + 95, text] # add 95 to place label above button
+  def input_move_magenta
+    if inputs.keyboard.key_held.w
+      state.player_magenta.dy = 5
+      state.player_magenta.orientation = "up"
+    elsif inputs.keyboard.key_held.s
+      state.player_magenta.dy = -5
+      state.player_magenta.orientation = "down"
+    else
+      state.player_magenta.dy *= 0.8
+    end
+    if inputs.keyboard.key_held.a
+      state.player_magenta.dx = -5
+      state.player_magenta.orientation = "left"
+    elsif inputs.keyboard.key_held.d
+      state.player_magenta.dx = 5
+      state.player_magenta.orientation = "right"
+    else
+      state.player_magenta.dx *= 0.8
     end
 
-    outputs.labels << [10, 60, "Left Analog x: #{inputs.controller_one.left_analog_x_raw} (#{inputs.controller_one.left_analog_x_perc * 100}%)"]
-    outputs.labels << [10, 30, "Left Analog y: #{inputs.controller_one.left_analog_y_raw} (#{inputs.controller_one.left_analog_y_perc * 100}%)"]
-    outputs.labels << [900, 60, "Right Analog x: #{inputs.controller_one.right_analog_x_raw} (#{inputs.controller_one.right_analog_x_perc * 100}%)"]
-    outputs.labels << [900, 30, "Right Analog y: #{inputs.controller_one.right_analog_y_raw} (#{inputs.controller_one.right_analog_y_perc * 100}%)"]
+    outputs.labels << [128,360,"#{state.player_magenta.x.round()}",8,2,255,0,255,255]
+    outputs.labels << [128,328,"#{state.player_magenta.y.round()}",8,2,255,0,255,255]
   end
 end
 
-$controller_demo = ControllerDemo.new
+$camera_movement = CameraMovement.new
 
 def tick args
-  tick_instructions args, "Sample app shows how controller input is handled. You'll need to connect a USB controller."
-  $controller_demo.inputs = args.inputs
-  $controller_demo.state = args.state
-  $controller_demo.outputs = args.outputs
-  $controller_demo.tick
+  args.outputs.background_color = [0,0,0]
+  $camera_movement.inputs  = args.inputs
+  $camera_movement.outputs = args.outputs
+  $camera_movement.state   = args.state
+  $camera_movement.grid    = args.grid
+  $camera_movement.tick
 end
 
-# Resets the app.
-def r
-  $gtk.reset
-end
+
+Advanced Rendering - Z Targeting Camera - main.rb
+# ./samples/07_advanced_rendering/08_z_targeting_camera/app/main.rb
+class Game
+  attr_gtk
 
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
+  def tick
+    defaults
+    render
+    input
+    calc
   end
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
-end
+  def defaults
+    outputs.background_color = [219, 208, 191]
+    player.x        ||= 634
+    player.y        ||= 153
+    player.angle    ||= 90
+    player.distance ||= arena_radius
+    target.x        ||= 634
+    target.y        ||= 359
+  end
 
-

-Input Basics - Touch - main.rb
-# ./samples/02_input_basics/06_touch/app/main.rb
-def tick args
-  args.outputs.background_color = [ 0, 0, 0 ]
-  args.outputs.primitives << [640, 700, "Touch your screen.", 5, 1, 255, 255, 255].label
+  def render
+    outputs[:scene].sprites << ([0, 0, 933, 700, 'sprites/arena.png'].center_inside_rect grid.rect)
+    outputs[:scene].sprites << target_sprite
+    outputs[:scene].sprites << player_sprite
+    outputs.sprites << scene
+  end
 
-  # If you don't want to get fancy, you can just look for finger_one
-  #  (and _two, if you like), which are assigned in the order new touches hit
-  #  the screen. If not nil, they are touching right now, and are just
-  #  references to specific items in the args.input.touch hash.
-  # If finger_one lifts off, it will become nil, but finger_two, if it was
-  #  touching, remains until it also lifts off. When all fingers lift off, the
-  #  the next new touch will be finger_one again, but until then, new touches
-  #  don't fill in earlier slots.
-  if !args.inputs.finger_one.nil?
-    args.outputs.primitives << [640, 650, "Finger #1 is touching at (#{args.inputs.finger_one.x}, #{args.inputs.finger_one.y}).", 5, 1, 255, 255, 255].label
+  def target_sprite
+    {
+      x: target.x, y: target.y,
+      w: 10, h: 10,
+      path: 'sprites/square/black.png'
+    }.anchor_rect 0.5, 0.5
   end
-  if !args.inputs.finger_two.nil?
-    args.outputs.primitives << [640, 600, "Finger #2 is touching at (#{args.inputs.finger_two.x}, #{args.inputs.finger_two.y}).", 5, 1, 255, 255, 255].label
+
+  def input
+    if inputs.up && player.distance > 30
+      player.distance -= 2
+    elsif inputs.down && player.distance < 200
+      player.distance += 2
+    end
+
+    player.angle += inputs.left_right * -1
   end
 
-  # Here's the more flexible interface: this will report as many simultaneous
-  #  touches as the system can handle, but it's a little more effort to track
-  #  them. Each item in the args.input.touch hash has a unique key (an
-  #  incrementing integer) that exists until the finger lifts off. You can
-  #  tell which order the touches happened globally by the key value, or
-  #  by the touch[id].touch_order field, which resets to zero each time all
-  #  touches have lifted.
+  def calc
+    player.x = target.x + ((player.angle *  1).vector_x player.distance)
+    player.y = target.y + ((player.angle * -1).vector_y player.distance)
+  end
 
-  args.state.colors ||= [
-    0xFF0000, 0x00FF00, 0x1010FF, 0xFFFF00, 0xFF00FF, 0x00FFFF, 0xFFFFFF
-  ]
+  def player_sprite
+    {
+      x: player.x,
+      y: player.y,
+      w: 50,
+      h: 100,
+      path: 'sprites/player.png',
+      angle: (player.angle * -1) + 90
+    }.anchor_rect 0.5, 0
+  end
 
-  size = 100
-  args.inputs.touch.each { |k,v|
-    color = args.state.colors[v.touch_order % 7]
-    r = (color & 0xFF0000) >> 16
-    g = (color & 0x00FF00) >> 8
-    b = (color & 0x0000FF)
-    args.outputs.primitives << [v.x - (size / 2), v.y + (size / 2), size, size, r, g, b, 255].solid
-    args.outputs.primitives << [v.x, v.y + size, k.to_s, 0, 1, 0, 0, 0].label
-  }
+  def center_map
+    { x: 634, y: 359 }
+  end
+
+  def zoom_factor_single
+    2 - ((args.geometry.distance player, center_map).fdiv arena_radius)
+  end
+
+  def zoom_factor
+    zoom_factor_single ** 2
+  end
+
+  def arena_radius
+    206
+  end
+
+  def scene
+    {
+      x:    (640 - player.x) + (640 - (640 * zoom_factor)),
+      y:    (360 - player.y - (75 * zoom_factor)) + (320 - (320 * zoom_factor)),
+      w:    1280 * zoom_factor,
+      h:     720 * zoom_factor,
+      path: :scene,
+      angle: player.angle - 90,
+      angle_anchor_x: (player.x.fdiv 1280),
+      angle_anchor_y: (player.y.fdiv 720)
+    }
+  end
+
+  def player
+    state.player
+  end
+
+  def target
+    state.target
+  end
+end
+
+def tick args
+  $game ||= Game.new
+  $game.args = args
+  $game.tick
 end
 
+$gtk.reset
+
+
+Tweening Lerping Easing Functions - Easing Functions - main.rb
+# ./samples/08_tweening_lerping_easing_functions/01_easing_functions/app/main.rb
+def tick args
+  # STOP! Watch the following presentation first!!!!
+  # Math for Game Programmers: Fast and Funky 1D Nonlinear Transformations
+  # https://www.youtube.com/watch?v=mr5xkf6zSzk
+
+  # You've watched the talk, yes? YES???
+
+  # define starting and ending points of properties to animate
+  args.state.target_x = 1180
+  args.state.target_y = 620
+  args.state.target_w = 100
+  args.state.target_h = 100
+  args.state.starting_x = 0
+  args.state.starting_y = 0
+  args.state.starting_w = 300
+  args.state.starting_h = 300
+
+  # define start time and duration of animation
+  args.state.start_animate_at = 3.seconds # this is the same as writing 60 * 5 (or 300)
+  args.state.duration = 2.seconds # this is the same as writing 60 * 2 (or 120)
 
-

-Rendering Sprites - Animation Using Separate Pngs - main.rb
-# ./samples/03_rendering_sprites/01_animation_using_separate_pngs/app/main.rb
-=begin
+  # define type of animations
+  # Here are all the options you have for values you can put in the array:
+  # :identity, :quad, :cube, :quart, :quint, :flip
 
- Reminders:
+  # Linear is defined as:
+  # [:identity]
+  #
+  # Smooth start variations are:
+  # [:quad]
+  # [:cube]
+  # [:quart]
+  # [:quint]
 
- - String interpolation: Uses #{} syntax; everything between the #{ and the } is evaluated
-   as Ruby code, and the placeholder is replaced with its corresponding value or result.
+  # Linear reversed, and smooth stop are the same as the animations defined above, but reversed:
+  # [:flip, :identity]
+  # [:flip, :quad, :flip]
+  # [:flip, :cube, :flip]
+  # [:flip, :quart, :flip]
+  # [:flip, :quint, :flip]
 
-   In this sample app, we're using string interpolation to iterate through images in the
-   sprites folder using their image path names.
+  # You can also do custom definitions. See the bottom of the file details
+  # on how to do that. I've defined a couple for you:
+  # [:smoothest_start]
+  # [:smoothest_stop]
 
- - args.outputs.sprites: An array. Values in this array generate sprites on the screen.
-   The parameters are [X, Y, WIDTH, HEIGHT, IMAGE PATH]
-   For more information about sprites, go to mygame/documentation/05-sprites.md.
+  # CHANGE THIS LINE TO ONE OF THE LINES ABOVE TO SEE VARIATIONS
+  args.state.animation_type = [:identity]
+  # args.state.animation_type = [:quad]
+  # args.state.animation_type = [:cube]
+  # args.state.animation_type = [:quart]
+  # args.state.animation_type = [:quint]
+  # args.state.animation_type = [:flip, :identity]
+  # args.state.animation_type = [:flip, :quad, :flip]
+  # args.state.animation_type = [:flip, :cube, :flip]
+  # args.state.animation_type = [:flip, :quart, :flip]
+  # args.state.animation_type = [:flip, :quint, :flip]
+  # args.state.animation_type = [:smoothest_start]
+  # args.state.animation_type = [:smoothest_stop]
 
- - args.outputs.labels: An array. Values in the array generate labels on the screen.
-   The parameters are [X, Y, TEXT, SIZE, ALIGNMENT, RED, GREEN, BLUE, ALPHA, FONT STYLE]
-   For more information about labels, go to mygame/documentation/02-labels.md.
+  # THIS IS WHERE THE MAGIC HAPPENS!
+  # Numeric#ease
+  progress = args.state.start_animate_at.ease(args.state.duration, args.state.animation_type)
 
- - args.inputs.keyboard.key_down.KEY: Determines if a key is in the down state, or pressed.
-   Stores the frame that key was pressed on.
-   For more information about the keyboard, go to mygame/documentation/06-keyboard.md.
+  # Numeric#ease needs to called:
+  # 1. On the number that represents the point in time you want to start, and takes two parameters:
+  #   a. The first parameter is how long the animation should take.
+  #   b. The second parameter represents the functions that need to be called.
+  #
+  # For example, if I wanted an animate to start 3 seconds in, and last for 10 seconds,
+  # and I want to animation to start fast and end slow, I would do:
+  # (60 * 3).ease(60 * 10, :flip, :quint, :flip)
 
-=end
+  #        initial value           delta to the final value
+  calc_x = args.state.starting_x + (args.state.target_x - args.state.starting_x) * progress
+  calc_y = args.state.starting_y + (args.state.target_y - args.state.starting_y) * progress
+  calc_w = args.state.starting_w + (args.state.target_w - args.state.starting_w) * progress
+  calc_h = args.state.starting_h + (args.state.target_h - args.state.starting_h) * progress
 
-# This sample app demonstrates how sprite animations work.
-# There are two sprites that animate forever and one sprite
-# that *only* animates when you press the "f" key on the keyboard.
+  args.outputs.solids << [calc_x, calc_y, calc_w, calc_h, 0, 0, 0]
 
-# This is the entry point to your game. The `tick` method
-# executes at 60 frames per second. There are two methods
-# in this tick "entry point": `looping_animation`, and the
-# second method is `one_time_animation`.
-def tick args
-  looping_animation args
-  one_time_animation args
+  # count down
+  count_down = args.state.start_animate_at - args.state.tick_count
+  if count_down > 0
+    args.outputs.labels << [640, 375, "Running: #{args.state.animation_type} in...", 3, 1]
+    args.outputs.labels << [640, 345, "%.2f" % count_down.fdiv(60), 3, 1]
+  elsif progress >= 1
+    args.outputs.labels << [640, 360, "Click screen to reset.", 3, 1]
+    if args.inputs.click
+      $gtk.reset
+    end
+  end
 end
 
-# This function shows how to animate a sprite that loops forever.
-def looping_animation args
-  # Here we define a few local variables that will be sent
-  # into the magic function that gives us the correct sprite image
-  # over time. There are four things we need in order to figure
-  # out which sprite to show.
+# $gtk.reset
 
-  # 1. When to start the animation.
-  start_looping_at = 0
+# you can make own variations of animations using this
+module Easing
+  # you have access to all the built in functions: identity, flip, quad, cube, quart, quint
+  def self.smoothest_start x
+    quad(quint(x))
+  end
 
-  # 2. The number of pngs that represent the full animation.
-  number_of_sprites = 6
+  def self.smoothest_stop x
+    flip(quad(quint(flip(x))))
+  end
 
-  # 3. How long to show each png.
-  number_of_frames_to_show_each_sprite = 4
+  # this is the source for the existing easing functions
+  def self.identity x
+    x
+  end
 
-  # 4. Whether the animation should loop once, or forever.
-  does_sprite_loop = true
+  def self.flip x
+    1 - x
+  end
 
-  # With the variables defined above, we can get a number
-  # which represents the sprite to show by calling the `frame_index` function.
-  # In this case the number will be between 0, and 5 (you can see the sprites
-  # in the ./sprites directory).
-  sprite_index = start_looping_at.frame_index number_of_sprites,
-                                              number_of_frames_to_show_each_sprite,
-                                              does_sprite_loop
+  def self.quad x
+    x * x
+  end
 
-  # Now that we have `sprite_index, we can present the correct file.
-  args.outputs.sprites << [100, 100, 100, 100, "sprites/dragon_fly_#{sprite_index}.png"]
+  def self.cube x
+    x * x * x
+  end
 
-  # Try changing the numbers below to see how the animation changes:
-  args.outputs.sprites << [100, 200, 100, 100, "sprites/dragon_fly_#{0.frame_index 6, 4, true}.png"]
+  def self.quart x
+    x * x * x * x * x
+  end
+
+  def self.quint x
+    x * x * x * x * x * x
+  end
 end
 
-# This function shows how to animate a sprite that executes
-# only once when the "f" key is pressed.
-def one_time_animation args
-  # This is just a label the shows instructions within the game.
-  args.outputs.labels << [220, 350, "(press f to animate)"]
+
+Tweening Lerping Easing Functions - Cubic Bezier - main.rb
+# ./samples/08_tweening_lerping_easing_functions/02_cubic_bezier/app/main.rb
+def tick args
+  args.outputs.background_color = [33, 33, 33]
+  args.outputs.lines << bezier(100, 100,
+                               100, 620,
+                               1180, 620,
+                               1180, 100,
+                               0)
 
-  # If "f" is pressed on the keyboard...
-  if args.inputs.keyboard.key_down.f
-    # Print the frame that "f" was pressed on.
-    puts "Hello from main.rb! The \"f\" key was in the down state on frame: #{args.inputs.keyboard.key_down.f}"
+  args.outputs.lines << bezier(100, 100,
+                               100, 620,
+                               1180, 620,
+                               1180, 100,
+                               20)
+end
 
-    # And MOST IMPORTANTLY set the point it time to start the animation,
-    # equal to "now" which is represented as args.state.tick_count.
 
-    # Also IMPORTANT, you'll notice that the value of when to start looping
-    # is stored in `args.state`. This construct's values are retained across
-    # executions of the `tick` method.
-    args.state.start_looping_at = args.state.tick_count
+def bezier x1, y1, x2, y2, x3, y3, x4, y4, step
+  step ||= 0
+  color = [200, 200, 200]
+  points = points_for_bezier [x1, y1], [x2, y2], [x3, y3], [x4, y4], step
+
+  points.each_cons(2).map do |p1, p2|
+    [p1, p2, color]
   end
+end
 
-  # These are the same local variables that were defined
-  # for the `looping_animation` function.
-  number_of_sprites = 6
-  number_of_frames_to_show_each_sprite = 4
+def points_for_bezier p1, p2, p3, p4, step
+  points = []
+  if step == 0
+    [p1, p2, p3, p4]
+  else
+    t_step = 1.fdiv(step + 1)
+    t = 0
+    t += t_step
+    points = []
+    while t < 1
+      points << [
+        b_for_t(p1.x, p2.x, p3.x, p4.x, t),
+        b_for_t(p1.y, p2.y, p3.y, p4.y, t),
+      ]
+      t += t_step
+    end
 
-  # Except this sprite does not loop again. If the animation time has passed,
-  # then the frame_index function returns nil.
-  does_sprite_loop = false
+    [
+      p1,
+      *points,
+      p4
+    ]
+  end
+end
 
-  sprite_index = args.state
-                     .start_looping_at
-                     .frame_index number_of_sprites,
-                                  number_of_frames_to_show_each_sprite,
-                                  does_sprite_loop
+def b_for_t v0, v1, v2, v3, t
+  pow(1 - t, 3) * v0 +
+  3 * pow(1 - t, 2) * t * v1 +
+  3 * (1 - t) * pow(t, 2) * v2 +
+  pow(t, 3) * v3
+end
 
-  # This line sets the frame index to zero, if
-  # the animation duration has passed (frame_index returned nil).
+def pow n, to
+  n ** to
+end
 
-  # Remeber: we are not looping forever here.
-  sprite_index ||= 0
+
+Tweening Lerping Easing Functions - Easing Using Spline - main.rb
+# ./samples/08_tweening_lerping_easing_functions/03_easing_using_spline/app/main.rb
+def tick args
+  args.state.duration = 10.seconds
+  args.state.spline = [
+    [0.0, 0.33, 0.66, 1.0],
+    [1.0, 1.0,  1.0,  1.0],
+    [1.0, 0.66, 0.33, 0.0],
+  ]
 
-  # Present the sprite.
-  args.outputs.sprites << [100, 300, 100, 100, "sprites/dragon_fly_#{sprite_index}.png"]
+  args.state.simulation_tick = args.state.tick_count % args.state.duration
+  progress = 0.ease_spline_extended args.state.simulation_tick, args.state.duration, args.state.spline
+  args.outputs.borders << args.grid.rect
+  args.outputs.solids << [20 + 1240 * progress,
+                          20 +  680 * progress,
+                          20, 20].anchor_rect(0.5, 0.5)
+  args.outputs.labels << [10,
+                          710,
+                          "perc: #{"%.2f" % (args.state.simulation_tick / args.state.duration)} t: #{args.state.simulation_tick}"]
+end
 
-  tick_instructions args, "Sample app shows how to use Numeric#frame_index and string interpolation to animate a sprite over time."
+
+Tweening Lerping Easing Functions - Parametric Enemy Movement - main.rb
+# ./samples/08_tweening_lerping_easing_functions/04_parametric_enemy_movement/app/main.rb
+def new_star args
+  { x: 1280.randomize(:ratio),
+    starting_y: 800,
+    distance_to_travel: 900 + 100.randomize(:ratio),
+    duration: 100.randomize(:ratio) + 60,
+    created_at: args.state.tick_count,
+    max_alpha: 128.randomize(:ratio) + 128,
+    b: 255.randomize(:ratio),
+    g: 200.randomize(:ratio),
+    w: 1.randomize(:ratio) + 1,
+    h: 1.randomize(:ratio) + 1 }
 end
 
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
-  end
+def new_enemy args
+  { x: 1280.randomize(:ratio),
+    starting_y: 800,
+    distance_to_travel: -900,
+    duration: 60.randomize(:ratio) + 180,
+    created_at: args.state.tick_count,
+    w: 32,
+    h: 32,
+    fire_rate: (30.randomize(:ratio) + (60 - args.state.score)).to_i }
+end
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+def new_bullet args, starting_x, starting_y, enemy_speed
+  { x: starting_x,
+    starting_y: starting_y,
+    distance_to_travel: -900,
+    created_at: args.state.tick_count,
+    duration: 900 / (enemy_speed.abs + 2.0 + (5.0 * args.state.score.fdiv(100))).abs,
+    w: 5,
+    h: 5 }
 end
 
-

-Rendering Sprites - Animation Using Sprite Sheet - main.rb
-# ./samples/03_rendering_sprites/02_animation_using_sprite_sheet/app/main.rb
-def tick args
-  args.state.player.x ||= 100
-  args.state.player.y ||= 100
-  args.state.player.w ||= 64
-  args.state.player.h ||= 64
-  args.state.player.direction ||= 1
+def new_player_bullet args, starting_x, starting_y, player_speed
+  { x: starting_x,
+    starting_y: starting_y,
+    distance_to_travel: 900,
+    created_at: args.state.tick_count,
+    duration: 900 / (player_speed + 2.0),
+    w: 5,
+    h: 5 }
+end
 
-  args.state.player.is_moving = false
+def defaults args
+  args.outputs.background_color  = [0, 0, 0]
+  args.state.score             ||= 0
+  args.state.stars             ||= []
+  args.state.enemies           ||= []
+  args.state.bullets           ||= []
+  args.state.player_bullets    ||= []
+  args.state.max_stars           = 50
+  args.state.max_enemies         = 10
+  args.state.player.x          ||= 640
+  args.state.player.y          ||= 100
+  args.state.player.w          ||= 32
+  args.state.player.h          ||= 32
 
-  # get the keyboard input and set player properties
-  if args.inputs.keyboard.right
-    args.state.player.x += 3
-    args.state.player.direction = 1
-    args.state.player.started_running_at ||= args.state.tick_count
-  elsif args.inputs.keyboard.left
-    args.state.player.x -= 3
-    args.state.player.direction = -1
-    args.state.player.started_running_at ||= args.state.tick_count
+  if args.state.tick_count == 0
+    args.state.stars.clear
+    args.state.max_stars.times do
+      s = new_star args
+      s[:created_at] += s[:duration].randomize(:ratio)
+      args.state.stars << s
+    end
   end
 
-  if args.inputs.keyboard.up
-    args.state.player.y += 1
-    args.state.player.started_running_at ||= args.state.tick_count
-  elsif args.inputs.keyboard.down
-    args.state.player.y -= 1
-    args.state.player.started_running_at ||= args.state.tick_count
+  if args.state.tick_count == 0
+    args.state.enemies.clear
+    args.state.max_enemies.times do
+      s = new_enemy args
+      s[:created_at] += s[:duration].randomize(:ratio)
+      args.state.enemies << s
+    end
   end
+end
 
-  # if no arrow keys are being pressed, set the player as not moving
-  if !args.inputs.keyboard.directional_vector
-    args.state.player.started_running_at = nil
+def input args
+  if args.inputs.keyboard.left
+    args.state.player.x -= 5
+  elsif args.inputs.keyboard.right
+    args.state.player.x += 5
   end
 
-  # wrap player around the stage
-  if args.state.player.x > 1280
-    args.state.player.x = -64
-    args.state.player.started_running_at ||= args.state.tick_count
-  elsif args.state.player.x < -64
-    args.state.player.x = 1280
-    args.state.player.started_running_at ||= args.state.tick_count
+  if args.inputs.keyboard.up
+    args.state.player.y += 5
+  elsif args.inputs.keyboard.down
+    args.state.player.y -= 5
   end
 
-  if args.state.player.y > 720
-    args.state.player.y = -64
-    args.state.player.started_running_at ||= args.state.tick_count
-  elsif args.state.player.y < -64
-    args.state.player.y = 720
-    args.state.player.started_running_at ||= args.state.tick_count
+  if args.inputs.keyboard.key_down.space
+    args.state.player_bullets << new_player_bullet(args,
+                                                   args.state.player.x + args.state.player.w.half,
+                                                   args.state.player.y + args.state.player.h, 5)
   end
 
-  # render player as standing or running
-  if args.state.player.started_running_at
-    args.outputs.sprites << running_sprite(args)
-  else
-    args.outputs.sprites << standing_sprite(args)
-  end
-  args.outputs.labels << [30, 700, "Use arrow keys to move around."]
+  args.state.player.y = args.state.player.y.greater(0).lesser(720 - args.state.player.w)
+  args.state.player.x = args.state.player.x.greater(0).lesser(1280 - args.state.player.h)
 end
 
-def standing_sprite args
-  {
-    x: args.state.player.x,
-    y: args.state.player.y,
-    w: args.state.player.w,
-    h: args.state.player.h,
-    path: "sprites/horizontal-stand.png",
-    flip_horizontally: args.state.player.direction > 0
-  }
+def completed? entity
+  (entity[:created_at] + entity[:duration]).elapsed_time > 0
 end
 
-def running_sprite args
-  if !args.state.player.started_running_at
-    tile_index = 0
-  else
-    how_many_frames_in_sprite_sheet = 6
-    how_many_ticks_to_hold_each_frame = 3
-    should_the_index_repeat = true
-    tile_index = args.state
-                     .player
-                     .started_running_at
-                     .frame_index(how_many_frames_in_sprite_sheet,
-                                  how_many_ticks_to_hold_each_frame,
-                                  should_the_index_repeat)
+def calc_stars args
+  if (stars_to_add = args.state.max_stars - args.state.stars.length) > 0
+    stars_to_add.times { args.state.stars << new_star(args) }
   end
-
-  {
-    x: args.state.player.x,
-    y: args.state.player.y,
-    w: args.state.player.w,
-    h: args.state.player.h,
-    path: 'sprites/horizontal-run.png',
-    tile_x: 0 + (tile_index * args.state.player.w),
-    tile_y: 0,
-    tile_w: args.state.player.w,
-    tile_h: args.state.player.h,
-    flip_horizontally: args.state.player.direction > 0,
-  }
+  args.state.stars = args.state.stars.reject { |s| completed? s }
 end
 
-
-Rendering Sprites - Animation States - main.rb
-# ./samples/03_rendering_sprites/03_animation_states/app/main.rb
-class Game
-  attr_gtk
-
-  def defaults
-    state.show_debug_layer  = true if state.tick_count == 0
-    player.tile_size        = 64
-    player.speed            = 3
-    player.slash_frames     = 15
-    player.x              ||= 50
-    player.y              ||= 400
-    player.dir_x          ||=  1
-    player.dir_y          ||= -1
-    player.is_moving      ||= false
-    state.watch_list      ||= {}
-    state.enemies         ||= []
-  end
-
-  def add_enemy
-    state.enemies << { x: 1200 * rand, y: 600 * rand, w: 64, h: 64 }
+def move_enemies args
+  if (enemies_to_add = args.state.max_enemies - args.state.enemies.length) > 0
+    enemies_to_add.times { args.state.enemies << new_enemy(args) }
   end
 
-  def sprite_horizontal_run
-    tile_index = 0.frame_index(6, 3, true)
-    tile_index = 0 if !player.is_moving
+  args.state.enemies = args.state.enemies.reject { |s| completed? s }
+end
 
-    {
-      x: player.x,
-      y: player.y,
-      w: player.tile_size,
-      h: player.tile_size,
-      path: 'sprites/horizontal-run.png',
-      tile_x: 0 + (tile_index * player.tile_size),
-      tile_y: 0,
-      tile_w: player.tile_size,
-      tile_h: player.tile_size,
-      flip_horizontally: player.dir_x > 0,
-      # a: 40
-    }
+def move_bullets args
+  args.state.enemies.each do |e|
+    if args.state.tick_count.mod_zero?(e[:fire_rate])
+      args.state.bullets << new_bullet(args, e[:x] + e[:w].half, current_y(e), e[:distance_to_travel] / e[:duration])
+    end
   end
 
-  def sprite_horizontal_stand
-    {
-      x: player.x,
-      y: player.y,
-      w: player.tile_size,
-      h: player.tile_size,
-      path: 'sprites/horizontal-stand.png',
-      flip_horizontally: player.dir_x > 0,
-      # a: 40
-    }
-  end
+  args.state.bullets = args.state.bullets.reject { |s| completed? s }
+  args.state.player_bullets = args.state.player_bullets.reject { |s| completed? s }
+end
 
-  def sprite_horizontal_slash
-    tile_index   = player.slash_at.frame_index(5, player.slash_frames.idiv(5), false) || 0
+def intersect? entity_one, entity_two
+  entity_one.merge(y: current_y(entity_one))
+            .intersect_rect? entity_two.merge(y: current_y(entity_two))
+end
 
-    {
-      x: player.x - 41.25,
-      y: player.y - 41.25,
-      w: 165,
-      h: 165,
-      path: 'sprites/horizontal-slash.png',
-      tile_x: 0 + (tile_index * 128),
-      tile_y: 0,
-      tile_w: 128,
-      tile_h: 128,
-      flip_horizontally: player.dir_x > 0
-    }
-  end
+def kill args
+  bullets_hitting_enemies = []
+  dead_bullets = []
+  dead_enemies = []
 
-  def render_player
-    if player.slash_at
-      outputs.sprites << sprite_horizontal_slash
-    elsif player.is_moving
-      outputs.sprites << sprite_horizontal_run
-    else
-      outputs.sprites << sprite_horizontal_stand
+  args.state.player_bullets.each do |b|
+    args.state.enemies.each do |e|
+      if intersect? b, e
+        dead_bullets << b
+        dead_enemies << e
+      end
     end
   end
 
-  def render_enemies
-    outputs.borders << state.enemies
+  args.state.score += dead_enemies.length
+
+  args.state.player_bullets.reject! { |b| dead_bullets.include? b }
+  args.state.enemies.reject! { |e| dead_enemies.include? e }
+
+  dead = args.state.bullets.any? do |b|
+    [args.state.player.x,
+     args.state.player.y,
+     args.state.player.w,
+     args.state.player.h].intersect_rect? b.merge(y: current_y(b))
   end
+  return unless dead
+  args.gtk.reset
+  defaults args
+end
 
-  def render_debug_layer
-    return if !state.show_debug_layer
-    outputs.labels << state.watch_list.map.with_index do |(k, v), i|
-       [30, 710 - i * 28, "#{k}: #{v || "(nil)"}"]
-    end
+def calc args
+  calc_stars args
+  move_enemies args
+  move_bullets args
+  kill args
+end
 
-    outputs.borders << player.slash_collision_rect
+def current_y entity
+  entity[:starting_y] + (entity[:distance_to_travel] * entity[:created_at].ease(entity[:duration], :identity))
+end
+
+def render args
+  args.outputs.solids << args.state.stars.map do |s|
+    [s[:x],
+     current_y(s),
+     s[:w], s[:h], 0, s[:g], s[:b], s[:max_alpha] * s[:created_at].ease(20, :identity)]
   end
 
-  def slash_initiate?
-    # buffalo usb controller has a button and b button swapped lol
-    inputs.controller_one.key_down.a || inputs.keyboard.key_down.j
+  args.outputs.borders << args.state.enemies.map do |s|
+    [s[:x],
+     current_y(s),
+     s[:w], s[:h], 255, 0, 0]
   end
 
-  def input
-    # player movement
-    if slash_complete? && (vector = inputs.directional_vector)
-      player.x += vector.x * player.speed
-      player.y += vector.y * player.speed
-    end
-    player.slash_at = slash_initiate? if slash_initiate?
+  args.outputs.borders << args.state.bullets.map do |b|
+    [b[:x],
+     current_y(b),
+     b[:w], b[:h], 255, 0, 0]
   end
 
-  def calc_movement
-    # movement
-    if vector = inputs.directional_vector
-      state.debug_label = vector
-      player.dir_x = vector.x
-      player.dir_y = vector.y
-      player.is_moving = true
-    else
-      state.debug_label = vector
-      player.is_moving = false
-    end
+  args.outputs.borders << args.state.player_bullets.map do |b|
+    [b[:x],
+     current_y(b),
+     b[:w], b[:h], 255, 255, 255]
   end
 
-  def calc_slash
-    # re-calc the location of the swords collision box
-    if player.dir_x.positive?
-      player.slash_collision_rect = [player.x + player.tile_size,
-                                     player.y + player.tile_size.half - 10,
-                                     40, 20]
-    else
-      player.slash_collision_rect = [player.x - 32 - 8,
-                                     player.y + player.tile_size.half - 10,
-                                     40, 20]
-    end
+  args.borders << [args.state.player.x,
+                   args.state.player.y,
+                   args.state.player.w,
+                   args.state.player.h, 255, 255, 255]
+end
 
-    # recalc sword's slash state
-    player.slash_at = nil if slash_complete?
+def tick args
+  defaults args
+  input args
+  calc args
+  render args
+end
 
-    # determine collision if the sword is at it's point of damaging
-    return unless slash_can_damage?
+
+Performance - Sprites As Hash - main.rb
+# ./samples/09_performance/01_sprites_as_hash/app/main.rb
 
-    state.enemies.reject! { |e| e.intersect_rect? player.slash_collision_rect }
-  end
+# Sprites represented as Hashes using the queue ~args.outputs.sprites~
+# code up, but are the "slowest" to render.
+# The reason for this is the access of the key in the Hash and also
+# because the data args.outputs.sprites is cleared every tick.
+def random_x args
+  (args.grid.w.randomize :ratio) * -1
+end
 
-  def slash_complete?
-    !player.slash_at || player.slash_at.elapsed?(player.slash_frames)
-  end
+def random_y args
+  (args.grid.h.randomize :ratio) * -1
+end
 
-  def slash_can_damage?
-    # damage occurs half way into the slash animation
-    return false if slash_complete?
-    return false if (player.slash_at + player.slash_frames.idiv(2)) != state.tick_count
-    return true
-  end
+def random_speed
+  1 + (4.randomize :ratio)
+end
 
-  def calc
-    # generate an enemy if there aren't any on the screen
-    add_enemy if state.enemies.length == 0
-    calc_movement
-    calc_slash
+def new_star args
+  {
+    x: (random_x args),
+    y: (random_y args),
+    w: 4, h: 4, path: 'sprites/tiny-star.png',
+    s: random_speed
+  }
+end
+
+def move_star args, star
+  star.x += star[:s]
+  star.y += star[:s]
+  if star.x > args.grid.w || star.y > args.grid.h
+    star.x = (random_x args)
+    star.y = (random_y args)
+    star[:s] = random_speed
   end
+end
 
-  # source is at http://github.com/amirrajan/dragonruby-link-to-the-past
-  def tick
-    defaults
-    render_enemies
-    render_player
-    outputs.labels << [30, 30, "Gamepad: D-Pad to move. B button to attack."]
-    outputs.labels << [30, 52, "Keyboard: WASD/Arrow keys to move. J to attack."]
-    render_debug_layer
-    input
-    calc
+def tick args
+  args.state.star_count ||= 0
+
+  # sets console command when sample app initially opens
+  if Kernel.global_tick_count == 0
+    puts "* INFO - Please specify the number of sprites to render."
+    args.gtk.console.set_command "reset_with count: 100"
   end
 
-  def player
-    state.player
+  # init
+  if args.state.tick_count == 0
+    args.state.stars = args.state.star_count.map { |i| new_star args }
   end
+
+  # update
+  args.state.stars.each { |s| move_star args, s }
+
+  # render
+  args.outputs.sprites << args.state.stars
+  args.outputs.background_color = [0, 0, 0]
+  args.outputs.primitives << args.gtk.current_framerate_primitives
 end
 
-$game = Game.new
+# resets game, and assigns star count given by user
+def reset_with count: count
+  $gtk.reset
+  $gtk.args.state.star_count = count
+end
 
-def tick args
-  $game.args = args
-  $game.tick
+
+Performance - Sprites As Entities - main.rb
+# ./samples/09_performance/02_sprites_as_entities/app/main.rb
+# Sprites represented as Entities using the queue ~args.outputs.sprites~
+# yields nicer access apis over Hashes, but require a bit more code upfront.
+# The hash sample has to use star[:s] to get the speed of the star, but
+# an entity can use .s instead.
+def random_x args
+  (args.grid.w.randomize :ratio) * -1
 end
 
-$gtk.reset
+def random_y args
+  (args.grid.h.randomize :ratio) * -1
+end
 
-

-Rendering Sprites - Color And Rotation - main.rb
-# ./samples/03_rendering_sprites/04_color_and_rotation/app/main.rb
-=begin
- APIs listing that haven't been encountered in previous sample apps:
+def random_speed
+  1 + (4.randomize :ratio)
+end
 
- - merge: Returns a hash containing the contents of two original hashes.
-   Merge does not allow duplicate keys, so the value of a repeated key
-   will be overwritten.
+def new_star args
+  args.state.new_entity :star, {
+    x: (random_x args),
+    y: (random_y args),
+    w: 4, h: 4,
+    path: 'sprites/tiny-star.png',
+    s: random_speed
+  }
+end
 
-   For example, if we had two hashes
-   h1 = { "a" => 1, "b" => 2}
-   h2 = { "b" => 3, "c" => 3}
-   and we called the command
-   h1.merge(h2)
-   the result would the following hash
-   { "a" => 1, "b" => 3, "c" => 3}.
+def move_star args, star
+  star.x += star.s
+  star.y += star.s
+  if star.x > args.grid.w || star.y > args.grid.h
+    star.x = (random_x args)
+    star.y = (random_y args)
+    star.s = random_speed
+  end
+end
 
- Reminders:
+def tick args
+  args.state.star_count ||= 0
 
- - Hashes: Collection of unique keys and their corresponding values. The value can be found
-   using their keys.
-   In this sample app, we're using a hash to create a sprite.
+  # sets console command when sample app initially opens
+  if Kernel.global_tick_count == 0
+    puts "* INFO - Please specify the number of sprites to render."
+    args.gtk.console.set_command "reset_with count: 100"
+  end
+
+  # init
+  if args.state.tick_count == 0
+    args.state.stars = args.state.star_count.map { |i| new_star args }
+  end
 
- - args.outputs.sprites: An array. The values generate a sprite.
-   The parameters are [X, Y, WIDTH, HEIGHT, PATH, ANGLE, ALPHA, RED, GREEN, BLUE]
-   Before continuing with this sample app, it is HIGHLY recommended that you look
-   at mygame/documentation/05-sprites.md.
+  # update
+  args.state.stars.each { |s| move_star args, s }
 
- - args.inputs.keyboard.key_held.KEY: Determines if a key is being pressed.
-   For more information about the keyboard, go to mygame/documentation/06-keyboard.md.
+  # render
+  args.outputs.sprites << args.state.stars
+  args.outputs.background_color = [0, 0, 0]
+  args.outputs.primitives << args.gtk.current_framerate_primitives
+end
 
- - args.inputs.controller_one: Takes input from the controller based on what key is pressed.
-   For more information about the controller, go to mygame/documentation/08-controllers.md.
+# resets game, and assigns star count given by user
+def reset_with count: count
+  $gtk.reset
+  $gtk.args.state.star_count = count
+end
 
- - num1.lesser(num2): Finds the lower value of the given options.
+
+Performance - Sprites As Strict Entities - main.rb
+# ./samples/09_performance/03_sprites_as_strict_entities/app/main.rb
+# Sprites represented as StrictEntities using the queue ~args.outputs.sprites~
+# yields apis access similar to Entities, but all properties that can be set on the
+# entity must be predefined with a default value. Strict entities do not support the
+# addition of new properties after the fact. They are more performant than OpenEntities
+# because of this constraint.
+def random_x args
+  (args.grid.w.randomize :ratio) * -1
+end
 
-=end
+def random_y args
+  (args.grid.h.randomize :ratio) * -1
+end
 
-# This sample app shows a car moving across the screen. It loops back around if it exceeds the dimensions of the screen,
-# and also can be moved in different directions through keyboard input from the user.
+def random_speed
+  1 + (4.randomize :ratio)
+end
 
-# Calls the methods necessary for the game to run successfully.
-def tick args
-  default args
-  render args.grid, args.outputs, args.state
-  calc args.state
-  process_inputs args
+def new_star args
+  args.state.new_entity_strict(:star,
+                               x: (random_x args),
+                               y: (random_y args),
+                               w: 4, h: 4,
+                               path: 'sprites/tiny-star.png',
+                               s: random_speed) do |entity|
+    # invoke attr_sprite so that it responds to
+    # all properties that are required to render a sprite
+    entity.attr_sprite
+  end
 end
 
-# Sets default values for the car sprite
-# Initialization ||= only happens in the first frame
-def default args
-  args.state.sprite.width    = 19
-  args.state.sprite.height   = 10
-  args.state.sprite.scale    = 4
-  args.state.max_speed       = 5
-  args.state.x             ||= 100
-  args.state.y             ||= 100
-  args.state.speed         ||= 1
-  args.state.angle         ||= 0
+def move_star args, star
+  star.x += star.s
+  star.y += star.s
+  if star.x > args.grid.w || star.y > args.grid.h
+    star.x = (random_x args)
+    star.y = (random_y args)
+    star.s = random_speed
+  end
 end
 
-# Outputs sprite onto screen
-def render grid, outputs, state
-  outputs.solids  <<  [grid.rect, 70, 70, 70] # outputs gray background
-  outputs.sprites <<  [destination_rect(state), # sets first four parameters of car sprite
-  'sprites/86.png', # image path of car
-  state.angle,
-  opacity, # transparency
-  saturation,
-  source_rect(state), # sprite sub division/tile (tile x, y, w, h)
-  false, false,  # don't flip sprites
-  rotation_anchor]
+def tick args
+  args.state.star_count ||= 0
 
-  # also look at the create_sprite helper method
-  #
-  # For example:
-  #
-  # dest   = destination_rect(state)
-  # source = source_rect(state),
-  # outputs.sprites << create_sprite(
-  #   'sprites/86.png',
-  #   x: dest.x,
-  #   y: dest.y,
-  #   w: dest.w,
-  #   h: dest.h,
-  #   angle: state.angle,
-  #   source_x: source.x,
-  #   source_y: source.y,
-  #   source_w: source.w,
-  #   source_h: source.h,
-  #   flip_h: false,
-  #   flip_v: false,
-  #   rotation_anchor_x: 0.7,
-  #   rotation_anchor_y: 0.5
-  # )
+  # sets console command when sample app initially opens
+  if Kernel.global_tick_count == 0
+    puts "* INFO - Please specify the number of sprites to render."
+    args.gtk.console.set_command "reset_with count: 100"
+  end
+
+  # init
+  if args.state.tick_count == 0
+    args.state.stars = args.state.star_count.map { |i| new_star args }
+  end
+
+  # update
+  args.state.stars.each { |s| move_star args, s }
+
+  # render
+  args.outputs.sprites << args.state.stars
+  args.outputs.background_color = [0, 0, 0]
+  args.outputs.primitives << args.gtk.current_framerate_primitives
 end
 
-# Creates sprite by setting values inside of a hash
-def create_sprite path, options = {}
-  options = {
+# resets game, and assigns star count given by user
+def reset_with count: count
+  $gtk.reset
+  $gtk.args.state.star_count = count
+end
 
-    # dest x, y, w, h
-    x: 0,
-    y: 0,
-    w: 100,
-    h: 100,
+
+Performance - Sprites As Classes - main.rb
+# ./samples/09_performance/04_sprites_as_classes/app/main.rb
+# Sprites represented as Classes using the queue ~args.outputs.sprites~.
+# gives you full control of property declaration and method invocation.
+# They are more performant than OpenEntities and StrictEntities, but more code upfront.
+class Star
+  attr_sprite
 
-    # angle, rotation
-    angle: 0,
-    rotation_anchor_x: 0.5,
-    rotation_anchor_y: 0.5,
+  def initialize grid
+    @grid = grid
+    @x = (rand @grid.w) * -1
+    @y = (rand @grid.h) * -1
+    @w    = 4
+    @h    = 4
+    @s    = 1 + (4.randomize :ratio)
+    @path = 'sprites/tiny-star.png'
+  end
 
-    # color saturation (red, green, blue), transparency
-    r: 255,
-    g: 255,
-    b: 255,
-    a: 255,
+  def move
+    @x += @s
+    @y += @s
+    @x = (rand @grid.w) * -1 if @x > @grid.right
+    @y = (rand @grid.h) * -1 if @y > @grid.top
+  end
+end
 
-    # source x, y, width, height
-    source_x: 0,
-    source_y: 0,
-    source_w: -1,
-    source_h: -1,
+# calls methods needed for game to run properly
+def tick args
+  # sets console command when sample app initially opens
+  if Kernel.global_tick_count == 0
+    args.gtk.console.set_command "reset_with count: 100"
+  end
 
-    # flip horiztonally, flip vertically
-    flip_h: false,
-    flip_v: false,
+  # init
+  if args.state.tick_count == 0
+    args.state.stars = args.state.star_count.map { |i| Star.new args.grid }
+  end
 
-  }.merge options
+  # update
+  args.state.stars.each(&:move)
 
-  [
-    options[:x], options[:y], options[:w], options[:h], # dest rect keys
-    path,
-    options[:angle], options[:a], options[:r], options[:g], options[:b], # angle, color, alpha
-    options[:source_x], options[:source_y], options[:source_w], options[:source_h], # source rect keys
-    options[:flip_h], options[:flip_v], # flip
-    options[:rotation_anchor_x], options[:rotation_anchor_y], # rotation anchor
-  ] # hash keys contain corresponding values
+  # render
+  args.outputs.sprites << args.state.stars
+  args.outputs.background_color = [0, 0, 0]
+  args.outputs.primitives << args.gtk.current_framerate_primitives
 end
 
-# Calls the calc_pos and calc_wrap methods.
-def calc state
-  calc_pos state
-  calc_wrap state
+# resets game, and assigns star count given by user
+def reset_with count: count
+  $gtk.reset
+  $gtk.args.state.star_count = count
 end
 
-# Changes sprite's position on screen
-# Vectors have magnitude and direction, so the incremented x and y values give the car direction
-def calc_pos state
-  state.x     += state.angle.vector_x * state.speed # increments x by product of angle's x vector and speed
-  state.y     += state.angle.vector_y * state.speed # increments y by product of angle's y vector and speed
-  state.speed *= 1.1 # scales speed up
-  state.speed  = state.speed.lesser(state.max_speed) # speed is either current speed or max speed, whichever has a lesser value (ensures that the car doesn't go too fast or exceed the max speed)
+
+Performance - Static Sprites As Classes - main.rb
+# ./samples/09_performance/05_static_sprites_as_classes/app/main.rb
+# Sprites represented as Classes using the queue ~args.outputs.static_sprites~.
+# bypasses the queue behavior of ~args.outputs.sprites~. All instances are held
+# by reference. You get better performance, but you are mutating state of held objects
+# which is less functional/data oriented.
+class Star
+  attr_sprite
+
+  def initialize grid
+    @grid = grid
+    @x = (rand @grid.w) * -1
+    @y = (rand @grid.h) * -1
+    @w    = 4
+    @h    = 4
+    @s    = 1 + (4.randomize :ratio)
+    @path = 'sprites/tiny-star.png'
+  end
+
+  def move
+    @x += @s
+    @y += @s
+    @x = (rand @grid.w) * -1 if @x > @grid.right
+    @y = (rand @grid.h) * -1 if @y > @grid.top
+  end
 end
 
-# The screen's dimensions are 1280x720. If the car goes out of scope,
-# it loops back around on the screen.
-def calc_wrap state
+# calls methods needed for game to run properly
+def tick args
+  # sets console command when sample app initially opens
+  if Kernel.global_tick_count == 0
+    args.gtk.console.set_command "reset_with count: 100"
+  end
 
-  # car returns to left side of screen if it disappears on right side of screen
-  # sprite.width refers to tile's size, which is multipled by scale (4) to make it bigger
-  state.x = -state.sprite.width * state.sprite.scale if state.x - 20 > 1280
+  # init
+  if args.state.tick_count == 0
+    args.state.stars = args.state.star_count.map { |i| Star.new args.grid }
+  end
 
-  # car wraps around to right side of screen if it disappears on the left side
-  state.x = 1280 if state.x + state.sprite.width * state.sprite.scale + 20 < 0
+  # update
+  args.state.stars.each(&:move)
 
-  # car wraps around to bottom of screen if it disappears at the top of the screen
-  # if you subtract 520 pixels instead of 20 pixels, the car takes longer to reappear (try it!)
-  state.y = 0    if state.y - 20 > 720 # if 20 pixels less than car's y position is greater than vertical scope
+  # render
+  args.outputs.sprites << args.state.stars
+  args.outputs.background_color = [0, 0, 0]
+  args.outputs.primitives << args.gtk.current_framerate_primitives
+end
 
-  # car wraps around to top of screen if it disappears at the bottom of the screen
-  state.y = 720  if state.y + state.sprite.height * state.sprite.scale + 20 < 0
+# resets game, and assigns star count given by user
+def reset_with count: count
+  $gtk.reset
+  $gtk.args.state.star_count = count
 end
 
-# Changes angle of sprite based on user input from keyboard or controller
-def process_inputs args
+
+Performance - Static Sprites As Classes With Custom Drawing - main.rb
+# ./samples/09_performance/06_static_sprites_as_classes_with_custom_drawing/app/main.rb
+# Sprites represented as Classes, with a draw_override method, and using the queue ~args.outputs.static_sprites~.
+# is the fastest approach. This is comparable to what other game engines set as the default behavior.
+# There are tradeoffs for all this speed if the creation of a full blown class, and bypassing
+# functional/data-oriented practices.
+class Star
+  def initialize grid
+    @grid = grid
+    @x = (rand @grid.w) * -1
+    @y = (rand @grid.h) * -1
+    @w    = 4
+    @h    = 4
+    @s    = 1 + (4.randomize :ratio)
+    @path = 'sprites/tiny-star.png'
+  end
 
-  # NOTE: increasing the angle doesn't mean that the car will continue to go
-  # in a specific direction. The angle is increasing, which means that if the
-  # left key was kept in the "down" state, the change in the angle would cause
-  # the car to go in a counter-clockwise direction and form a circle (360 degrees)
-  if args.inputs.keyboard.key_held.left # if left key is pressed
-    args.state.angle += 2 # car's angle is incremented by 2
+  def move
+    @x += @s
+    @y += @s
+    @x = (rand @grid.w) * -1 if @x > @grid.right
+    @y = (rand @grid.h) * -1 if @y > @grid.top
+  end
 
-  # The same applies to decreasing the angle. If the right key was kept in the
-  # "down" state, the decreasing angle would cause the car to go in a clockwise
-  # direction and form a circle (360 degrees)
-  elsif args.inputs.keyboard.key_held.right # if right key is pressed
-    args.state.angle -= 2 # car's angle is decremented by 2
+  # if the object that is in args.outputs.sprites (or static_sprites)
+  # respond_to? :draw_override, then the method is invoked giving you
+  # access to the class used to draw to the canvas.
+  def draw_override ffi_draw
+    # first move then draw
+    move
 
-  # Input from a controller can also change the angle of the car
-  elsif args.inputs.controller_one.left_analog_x_perc != 0
-    args.state.angle += 2 * args.inputs.controller_one.left_analog_x_perc * -1
-  end
-end
+    # The argument order for ffi.draw_sprite is:
+    # x, y, w, h, path
+    ffi_draw.draw_sprite @x, @y, @w, @h, @path
 
-# A sprite's center of rotation can be altered
-# Increasing either of these numbers would dramatically increase the
-# car's drift when it turns!
-def rotation_anchor
-  [0.7, 0.5]
-end
+    # The argument order for ffi_draw.draw_sprite_2 is (pass in nil for default value):
+    # x, y, w, h, path,
+    # angle, alpha
 
-# Sets opacity value of sprite to 255 so that it is not transparent at all
-# Change it to 0 and you won't be able to see the car sprite on the screen
-def opacity
-  255
+    # The argument order for ffi_draw.draw_sprite_3 is:
+    # x, y, w, h,
+    # path,
+    # angle,
+    # alpha, red_saturation, green_saturation, blue_saturation
+    # flip_horizontally, flip_vertically,
+    # tile_x, tile_y, tile_w, tile_h
+    # angle_anchor_x, angle_anchor_y,
+    # source_x, source_y, source_w, source_h
+  end
 end
 
-# Sets the color of the sprite to white.
-def saturation
-  [255, 255, 255]
-end
+# calls methods needed for game to run properly
+def tick args
+  # sets console command when sample app initially opens
+  if Kernel.global_tick_count == 0
+    args.gtk.console.set_command "reset_with count: 100"
+  end
 
-# Sets definition of destination_rect (used to define the car sprite)
-def destination_rect state
-  [state.x, state.y,
-  state.sprite.width  * state.sprite.scale, # multiplies by 4 to set size
-  state.sprite.height * state.sprite.scale]
+  # init
+  if args.state.tick_count == 0
+    args.state.stars = args.state.star_count.map { |i| Star.new args.grid }
+    args.outputs.static_sprites << args.state.stars
+  end
+
+  # render framerate
+  args.outputs.background_color = [0, 0, 0]
+  args.outputs.primitives << args.gtk.current_framerate_primitives
 end
 
-# Portion of a sprite (a tile)
-# Sub division of sprite is denoted as a rectangle directly related to original size of .png
-# Tile is located at bottom left corner within a 19x10 pixel rectangle (based on sprite.width, sprite.height)
-def source_rect state
-  [0, 0, state.sprite.width, state.sprite.height]
+# resets game, and assigns star count given by user
+def reset_with count: count
+  $gtk.reset
+  $gtk.args.state.star_count = count
 end
 
-

-Physics And Collisions - Simple - main.rb
-# ./samples/04_physics_and_collisions/01_simple/app/main.rb
+
+Performance - Collision Limits - main.rb
+# ./samples/09_performance/07_collision_limits/app/main.rb
 =begin
 
  Reminders:
- - ARRAY#intersect_rect?: Returns true or false depending on if the two rectangles intersect.
+ - find_all: Finds all elements of a collection that meet certain requirements.
+   In this sample app, we're finding all bodies that intersect with the center body.
 
  - args.outputs.solids: An array. The values generate a solid.
    The parameters are [X, Y, WIDTH, HEIGHT, RED, GREEN, BLUE]
+   For more information about solids, go to mygame/documentation/03-solids-and-borders.md.
+
+ - args.outputs.labels: An array. The values generate a label.
+   The parameters are [X, Y, TEXT, SIZE, ALIGNMENT, RED, GREEN, BLUE, ALPHA, FONT STYLE]
+   For more information about labels, go to mygame/documentation/02-labels.md.
+
+ - ARRAY#intersect_rect?: Returns true or false depending on if two rectangles intersect.
 
 =end
 
-# This sample app shows collisions between two boxes.
+# This code demonstrates moving objects that loop around once they exceed the scope of the screen,
+# which has dimensions of 1280 by 720, and also detects collisions between objects called "bodies".
 
-# Runs methods needed for game to run properly.
-def tick args
-  tick_instructions args, "Sample app shows how to move a square over time and determine collision."
-  defaults args
-  render args
-  calc args
+def body_count num
+  $gtk.args.state.other_bodies = num.map { [1280 * rand, 720 * rand, 10, 10] } # other_bodies set using num collection
 end
 
-# Sets default values.
-def defaults args
-  # These values represent the moving box.
-  args.state.moving_box_speed   = 10
-  args.state.moving_box_size    = 100
-  args.state.moving_box_dx    ||=  1
-  args.state.moving_box_dy    ||=  1
-  args.state.moving_box       ||= [0, 0, args.state.moving_box_size, args.state.moving_box_size] # moving_box_size is set as the width and height
+def tick args
 
-  # These values represent the center box.
-  args.state.center_box ||= [540, 260, 200, 200, 180]
-  args.state.center_box_collision ||= false # initially no collision
-end
+  # Center body's values are set using an array
+  # Map is used to set values of 2000 other bodies
+  # All bodies that intersect with center body are stored in collisions collection
+  args.state.center_body  ||= [640 - 100, 360 - 100, 200, 200] # calculations done to place body in center
+  args.state.other_bodies ||= 2000.map { [1280 * rand, 720 * rand, 10, 10] } # 2000 bodies given random position on screen
 
-def render args
-  # If the game state denotes that a collision has occured,
-  # render a solid square, otherwise render a border instead.
-  if args.state.center_box_collision
-    args.outputs.solids << args.state.center_box
-  else
-    args.outputs.borders << args.state.center_box
-  end
+  # finds all bodies that intersect with center body, stores them in collisions
+  collisions = args.state.other_bodies.find_all { |b| b.intersect_rect? args.state.center_body }
 
-  # Then render the moving box.
-  args.outputs.solids << args.state.moving_box
-end
+  args.borders << args.state.center_body # outputs center body as a black border
 
-# Generally in a pipeline for a game engine, you have rendering,
-# game simulation (calculation), and input processing.
-# This fuction represents the game simulation.
-def calc args
-  position_moving_box args
-  determine_collision_center_box args
+  # transparency changes based on number of collisions; the more collisions, the redder (more transparent) the box becomes
+  args.solids  << [args.state.center_body, 255, 0, 0, collisions.length * 5] # center body is red solid
+  args.solids  << args.state.other_bodies # other bodies are output as (black) solids, as well
+
+  args.labels  << [10, 30, args.gtk.current_framerate] # outputs frame rate in bottom left corner
+
+  # Bodies are returned to bottom left corner if positions exceed scope of screen
+  args.state.other_bodies.each do |b| # for each body in the other_bodies collection
+    b.x += 5 # x and y are both incremented by 5
+    b.y += 5
+    b.x = 0 if b.x > 1280 # x becomes 0 if star exceeds scope of screen (goes too far right)
+    b.y = 0 if b.y > 720 # y becomes 0 if star exceeds scope of screen (goes too far up)
+  end
 end
 
-# Changes the position of the moving box on the screen by multiplying the change in x (dx) and change in y (dy) by the speed,
-# and adding it to the current position.
-# dx and dy are positive if the box is moving right and up, respectively
-# dx and dy are negative if the box is moving left and down, respectively
-def position_moving_box args
-  args.state.moving_box.x += args.state.moving_box_dx * args.state.moving_box_speed
-  args.state.moving_box.y += args.state.moving_box_dy * args.state.moving_box_speed
+# Resets the game.
+$gtk.reset
 
-  # 1280x720 are the virtual pixels you work with (essentially 720p).
-  screen_width  = 1280
-  screen_height = 720
+
+Advanced Debugging - Trace Debugging - main.rb
+# ./samples/10_advanced_debugging/01_trace_debugging/app/main.rb
+class Game
+  attr_gtk
 
-  # Position of the box is denoted by the bottom left hand corner, in
-  # that case, we have to subtract the width of the box so that it stays
-  # in the scene (you can try deleting the subtraction to see how it
-  # impacts the box's movement).
-  if args.state.moving_box.x > screen_width - args.state.moving_box_size
-    args.state.moving_box_dx = -1 # moves left
-  elsif args.state.moving_box.x < 0
-    args.state.moving_box_dx =  1 # moves right
+  def method1 num
+    method2 num
+  end
+
+  def method2 num
+    method3 num
+  end
+
+  def method3 num
+    method4 num
+  end
+
+  def method4 num
+    if num == 1
+      puts "UNLUCKY #{num}."
+      state.unlucky_count += 1
+      if state.unlucky_count > 3
+        raise "NAT 1 finally occurred. Check app/trace.txt for all method invocation history."
+      end
+    else
+      puts "LUCKY #{num}."
+    end
+  end
+
+  def tick
+    state.roll_history ||= []
+    state.roll_history << rand(20) + 1
+    state.countdown ||= 600
+    state.countdown  -= 1
+    state.unlucky_count ||= 0
+    outputs.labels << [640, 360, "A dice roll of 1 will cause an exception.", 0, 1]
+    if state.countdown > 0
+      outputs.labels << [640, 340, "Dice roll countdown: #{state.countdown}", 0, 1]
+    else
+      state.attempts ||= 0
+      state.attempts  += 1
+      outputs.labels << [640, 340, "ROLLING! #{state.attempts}", 0, 1]
+    end
+    return if state.countdown > 0
+    method1 state.roll_history[-1]
   end
+end
 
-  # Here, we're making sure the moving box remains within the vertical scope of the screen
-  if args.state.moving_box.y > screen_height - args.state.moving_box_size # if the box moves too high
-    args.state.moving_box_dy = -1 # moves down
-  elsif args.state.moving_box.y < 0 # if the box moves too low
-    args.state.moving_box_dy =  1 # moves up
-  end
+$game = Game.new
+
+def tick args
+  trace! $game # <------------------- TRACING ENABLED FOR THIS OBJECT
+  $game.args = args
+  $game.tick
 end
 
-def determine_collision_center_box args
-  # Collision is handled by the engine. You simply have to call the
-  # `intersect_rect?` function.
-  if args.state.moving_box.intersect_rect? args.state.center_box # if the two boxes intersect
-    args.state.center_box_collision = true # then a collision happened
-  else
-    args.state.center_box_collision = false # otherwise, no collision happened
+
+Advanced Debugging - Trace Debugging Classes - main.rb
+# ./samples/10_advanced_debugging/02_trace_debugging_classes/app/main.rb
+class Foobar
+  def initialize
+    trace! # Trace is added to the constructor.
   end
-end
 
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
+  def clicky args
+    return unless args.inputs.mouse.click
+    try_rand rand
   end
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+  def try_rand num
+    return if num < 0.9
+    raise "Exception finally occurred. Take a look at logs/trace.txt #{num}."
+  end
 end
 
-

-Physics And Collisions - Moving Objects - main.rb
-# ./samples/04_physics_and_collisions/02_moving_objects/app/main.rb
-=begin
-
- APIs listing that haven't been encountered in previous sample apps:
-
- - Hashes: Collection of unique keys and their corresponding values. The value can be found
-   using their keys.
-
-   For example, if we have a "numbers" hash that stores numbers in English as the
-   key and numbers in Spanish as the value, we'd have a hash that looks like this...
-   numbers = { "one" => "uno", "two" => "dos", "three" => "tres" }
-   and on it goes.
-
-   Now if we wanted to find the corresponding value of the "one" key, we could say
-   puts numbers["one"]
-   which would print "uno" to the console.
-
- - num1.greater(num2): Returns the greater value.
-   For example, if we have the command
-   puts 4.greater(3)
-   the number 4 would be printed to the console since it has a greater value than 3.
-   Similar to lesser, which returns the lesser value.
-
- - num1.lesser(num2): Finds the lower value of the given options.
-   For example, in the statement
-   a = 4.lesser(3)
-   3 has a lower value than 4, which means that the value of a would be set to 3,
-   but if the statement had been
-   a = 4.lesser(5)
-   4 has a lower value than 5, which means that the value of a would be set to 4.
-
- - reject: Removes elements from a collection if they meet certain requirements.
-   For example, you can derive an array of odd numbers from an original array of
-   numbers 1 through 10 by rejecting all elements that are even (or divisible by 2).
-
- - find_all: Finds all values that satisfy specific requirements.
-   For example, you can find all elements of a collection that are divisible by 2
-   or find all objects that have intersected with another object.
-
- - abs: Returns the absolute value.
-   For example, the command
-   (-30).abs
-   would return 30 as a result.
-
- - map: Ruby method used to transform data; used in arrays, hashes, and collections.
-   Can be used to perform an action on every element of a collection, such as multiplying
-   each element by 2 or declaring every element as a new entity.
+def tick args
+  args.labels << [640, 360, "Start clicking. Eventually an exception will be thrown. Then look at logs/trace.txt.", 0, 1]
+  args.state.foobar = Foobar.new if args.tick_count
+  return unless args.state.foobar
+  args.state.foobar.clicky args
+end
 
- Reminders:
+
+Advanced Debugging - Unit Tests - exception_raising_tests.rb
+# ./samples/10_advanced_debugging/03_unit_tests/exception_raising_tests.rb
+begin :shared
+  class ExceptionalClass
+    def initialize exception_to_throw = nil
+      raise exception_to_throw if exception_to_throw
+    end
+  end
+end
 
- - args.inputs.keyboard.KEY: Determines if a key has been pressed.
-   For more information about the keyboard, take a look at mygame/documentation/06-keyboard.md.
+def test_exception_in_newing_object args, assert
+  begin
+    ExceptionalClass.new TypeError
+    raise "Exception wasn't thrown!"
+  rescue Exception => e
+    assert.equal! e.class, TypeError, "Exceptions within constructor should be retained."
+  end
+end
 
- - ARRAY#intersect_rect?: Returns true or false depending on if the two rectangles intersect.
+$gtk.reset 100
+$gtk.log_level = :off
 
- - args.outputs.solids: An array. The values generate a solid.
-   The parameters are [X, Y, WIDTH, HEIGHT, RED, GREEN, BLUE]
-   For more information about solids, go to mygame/documentation/03-solids-and-borders.md.
+
+Advanced Debugging - Unit Tests - fn_tests.rb
+# ./samples/10_advanced_debugging/03_unit_tests/fn_tests.rb
+def infinity
+  1 / 0
+end
+
+def neg_infinity
+  -1 / 0
+end
+
+def nan
+  0.0 / 0
+end
+
+def test_add args, assert
+  assert.equal! (args.fn.add), 0
+  assert.equal! (args.fn.+), 0
+  assert.equal! (args.fn.+ 1, 2, 3), 6
+  assert.equal! (args.fn.+ 0), 0
+  assert.equal! (args.fn.+ 0, nil), 0
+  assert.equal! (args.fn.+ 0, nan), nil
+  assert.equal! (args.fn.+ 0, nil, infinity), nil
+  assert.equal! (args.fn.+ [1, 2, 3, [4, 5, 6]]), 21
+  assert.equal! (args.fn.+ [nil, [4, 5, 6]]), 15
+end
+
+def test_sub args, assert
+  neg_infinity = infinity * -1
+  assert.equal! (args.fn.+), 0
+  assert.equal! (args.fn.- 1, 2, 3), -4
+  assert.equal! (args.fn.- 4), -4
+  assert.equal! (args.fn.- 4, nan), nil
+  assert.equal! (args.fn.- 0, nil), 0
+  assert.equal! (args.fn.- 0, nil, infinity), nil
+  assert.equal! (args.fn.- [0, 1, 2, 3, [4, 5, 6]]), -21
+  assert.equal! (args.fn.- [nil, 0, [4, 5, 6]]), -15
+end
+
+def test_div args, assert
+  assert.equal! (args.fn.div), 1
+  assert.equal! (args.fn./), 1
+  assert.equal! (args.fn./ 6, 3), 2
+  assert.equal! (args.fn./ 6, infinity), nil
+  assert.equal! (args.fn./ 6, nan), nil
+  assert.equal! (args.fn./ infinity), nil
+  assert.equal! (args.fn./ 0), nil
+  assert.equal! (args.fn./ 6, [3]), 2
+end
+
+def test_idiv args, assert
+  assert.equal! (args.fn.idiv), 1
+  assert.equal! (args.fn.idiv 7, 3), 2
+  assert.equal! (args.fn.idiv 6, infinity), nil
+  assert.equal! (args.fn.idiv 6, nan), nil
+  assert.equal! (args.fn.idiv infinity), nil
+  assert.equal! (args.fn.idiv 0), nil
+  assert.equal! (args.fn.idiv 7, [3]), 2
+end
+
+def test_mul args, assert
+  assert.equal! (args.fn.mul), 1
+  assert.equal! (args.fn.*), 1
+  assert.equal! (args.fn.* 7, 3), 21
+  assert.equal! (args.fn.* 6, nan), nil
+  assert.equal! (args.fn.* 6, infinity), nil
+  assert.equal! (args.fn.* infinity), nil
+  assert.equal! (args.fn.* 0), 0
+  assert.equal! (args.fn.* 7, [3]), 21
+end
+
+def test_lt args, assert
+  assert.equal! (args.fn.lt 1), 1
+  assert.equal! (args.fn.lt), nil
+  assert.equal! (args.fn.lt infinity), nil
+  assert.equal! (args.fn.lt nan), nil
+  assert.equal! (args.fn.lt 10, 9, 8), 8
+  assert.equal! (args.fn.< 10, 9, 8), 8
+  assert.equal! (args.fn.< [10, 9, [8]]), 8
+  assert.equal! (args.fn.< 10, 10), nil
+end
+
+def test_lte args, assert
+  assert.equal! (args.fn.lte 1), 1
+  assert.equal! (args.fn.lte), nil
+  assert.equal! (args.fn.lte infinity), nil
+  assert.equal! (args.fn.lte nan), nil
+  assert.equal! (args.fn.lte 10, 9, 8), 8
+  assert.equal! (args.fn.lte 10, 10), 10
+  assert.equal! (args.fn.lte  10, 9, [8]), 8
+  assert.equal! (args.fn.<=  10, 9, 8), 8
+end
+
+def test_gt args, assert
+  assert.equal! (args.fn.gt 1), 1
+  assert.equal! (args.fn.gt), nil
+  assert.equal! (args.fn.gt infinity), nil
+  assert.equal! (args.fn.gt nan), nil
+  assert.equal! (args.fn.gt 8, 9, 10), 10
+  assert.equal! (args.fn.gt [8, 9, [10]]), 10
+  assert.equal! (args.fn.gt 10, 10), nil
+  assert.equal! (args.fn.gt 10, 10), nil
+  assert.equal! (args.fn.gt 10, 9), nil
+  assert.equal! (args.fn.>  8, 9, 10), 10
+end
 
-=end
+def test_gte args, assert
+  assert.equal! (args.fn.gte 1), 1
+  assert.equal! (args.fn.gte), nil
+  assert.equal! (args.fn.gte infinity), nil
+  assert.equal! (args.fn.gte nan), nil
+  assert.equal! (args.fn.gte 8, 9, 10), 10
+  assert.equal! (args.fn.gte 10, 10), 10
+  assert.equal! (args.fn.gte 8, 9, [10]), 10
+  assert.equal! (args.fn.gte 10, 9), nil
+  assert.equal! (args.fn.>=  8, 9, 10), 10
+end
+
+
+def test_acopy args, assert
+  orig  = [1, 2, 3]
+  clone = args.fn.acopy orig
+  assert.equal! clone, [1, 2, 3]
+  assert.equal! clone, orig
+  assert.not_equal! clone.object_id, orig.object_id
+end
+
+def test_aget args, assert
+  assert.equal! (args.fn.aget [:a, :b, :c], 1), :b
+  assert.equal! (args.fn.aget [:a, :b, :c], nil), nil
+  assert.equal! (args.fn.aget nil, 1), nil
+end
+
+def test_alength args, assert
+  assert.equal! (args.fn.alength [:a, :b, :c]), 3
+  assert.equal! (args.fn.alength nil), nil
+end
 
-# Calls methods needed for game to run properly
-def tick args
-  tick_instructions args, "Use LEFT and RIGHT arrow keys to move and SPACE to jump."
-  defaults args
-  render args
-  calc args
-  input args
+def test_amap args, assert
+  inc = lambda { |i| i + 1 }
+  ary = [1, 2, 3]
+  assert.equal! (args.fn.amap ary, inc), [2, 3, 4]
+  assert.equal! (args.fn.amap nil, inc), nil
+  assert.equal! (args.fn.amap ary, nil), nil
+  assert.equal! (args.fn.amap ary, inc).class, Array
 end
 
-# sets default values and creates empty collections
-# initialization only happens in the first frame
-def defaults args
-  fiddle args
-  args.state.enemy.hammers ||= []
-  args.state.enemy.hammer_queue ||= []
-  args.state.tick_count = args.state.tick_count
-  args.state.bridge_top = 128
-  args.state.player.x  ||= 0                        # initializes player's properties
-  args.state.player.y  ||= args.state.bridge_top
-  args.state.player.w  ||= 64
-  args.state.player.h  ||= 64
-  args.state.player.dy ||= 0
-  args.state.player.dx ||= 0
-  args.state.enemy.x   ||= 800                      # initializes enemy's properties
-  args.state.enemy.y   ||= 0
-  args.state.enemy.w   ||= 128
-  args.state.enemy.h   ||= 128
-  args.state.enemy.dy  ||= 0
-  args.state.enemy.dx  ||= 0
-  args.state.game_over_at ||= 0
+def test_and args, assert
+  assert.equal! (args.fn.and 1, 2, 3, 4), 4
+  assert.equal! (args.fn.and 1, 2, nil, 4), nil
+  assert.equal! (args.fn.and), true
+end
+
+def test_or args, assert
+  assert.equal! (args.fn.or 1, 2, 3, 4), 1
+  assert.equal! (args.fn.or 1, 2, nil, 4), 1
+  assert.equal! (args.fn.or), nil
+  assert.equal! (args.fn.or nil, nil, false, 5, 10), 5
 end
 
-# sets enemy, player, hammer values
-def fiddle args
-  args.state.gravity                     = -0.3
-  args.state.enemy_jump_power            = 10       # sets enemy values
-  args.state.enemy_jump_interval         = 60
-  args.state.hammer_throw_interval       = 40       # sets hammer values
-  args.state.hammer_launch_power_default = 5
-  args.state.hammer_launch_power_near    = 2
-  args.state.hammer_launch_power_far     = 7
-  args.state.hammer_upward_launch_power  = 15
-  args.state.max_hammers_per_volley      = 10
-  args.state.gap_between_hammers         = 10
-  args.state.player_jump_power           = 10       # sets player values
-  args.state.player_jump_power_duration  = 10
-  args.state.player_max_run_speed        = 10
-  args.state.player_speed_slowdown_rate  = 0.9
-  args.state.player_acceleration         = 1
-  args.state.hammer_size                 = 32
+def test_eq_eq args, assert
+  assert.equal! (args.fn.eq?), true
+  assert.equal! (args.fn.eq? 1, 0), false
+  assert.equal! (args.fn.eq? 1, 1, 1), true
+  assert.equal! (args.fn.== 1, 1, 1), true
+  assert.equal! (args.fn.== nil, nil), true
 end
 
-# outputs objects onto the screen
-def render args
-  args.outputs.solids << 20.map_with_index do |i| # uses 20 squares to form bridge
-    # sets x by multiplying 64 to index to find pixel value (places all squares side by side)
-    # subtracts 64 from bridge_top because position is denoted by bottom left corner
-    [i * 64, args.state.bridge_top - 64, 64, 64]
-  end
-
-  args.outputs.solids << [args.state.x, args.state.y, args.state.w, args.state.h, 255, 0, 0]
-  args.outputs.solids << [args.state.player.x, args.state.player.y, args.state.player.w, args.state.player.h, 255, 0, 0] # outputs player onto screen (red box)
-  args.outputs.solids << [args.state.enemy.x, args.state.enemy.y, args.state.enemy.w, args.state.enemy.h, 0, 255, 0] # outputs enemy onto screen (green box)
-  args.outputs.solids << args.state.enemy.hammers # outputs enemy's hammers onto screen
+def test_apply args, assert
+  assert.equal! (args.fn.and [nil, nil, nil]), [nil, nil, nil]
+  assert.equal! (args.fn.apply [nil, nil, nil], args.fn.method(:and)), nil
+  and_lambda = lambda {|*xs| args.fn.and(*xs)}
+  assert.equal! (args.fn.apply [nil, nil, nil], and_lambda), nil
 end
 
-# Performs calculations to move objects on the screen
-def calc args
+def test_areduce args, assert
+  assert.equal! (args.fn.areduce [1, 2, 3], 0, lambda { |i, a| i + a }), 6
+end
 
-  # Since velocity is the change in position, the change in x increases by dx. Same with y and dy.
-  args.state.player.x  += args.state.player.dx
-  args.state.player.y  += args.state.player.dy
+def test_array_hash args, assert
+  assert.equal! (args.fn.array_hash :a, 1, :b, 2), { a: 1, b: 2 }
+  assert.equal! (args.fn.array_hash), { }
+end
 
-  # Since acceleration is the change in velocity, the change in y (dy) increases every frame
-  args.state.player.dy += args.state.gravity
+
+Advanced Debugging - Unit Tests - gen_docs.rb
+# ./samples/10_advanced_debugging/03_unit_tests/gen_docs.rb
+# ./dragonruby mygame --eval samples/99_zz_gtk_unit_tests/gen_docs.rb --no-tick
+Kernel.export_docs!
 
-  # player's y position is either current y position or y position of top of
-  # bridge, whichever has a greater value
-  # ensures that the player never goes below the bridge
-  args.state.player.y  = args.state.player.y.greater(args.state.bridge_top)
+
+Advanced Debugging - Unit Tests - geometry_tests.rb
+# ./samples/10_advanced_debugging/03_unit_tests/geometry_tests.rb
+begin :shared
+  def primitive_representations x, y, w, h
+    [
+      [x, y, w, h],
+      { x: x, y: y, w: w, h: h },
+      RectForTest.new(x, y, w, h)
+    ]
+  end
 
-  # player's x position is either the current x position or 0, whichever has a greater value
-  # ensures that the player doesn't go too far left (out of the screen's scope)
-  args.state.player.x  = args.state.player.x.greater(0)
+  class RectForTest
+    attr_sprite
 
-  # player is not falling if it is located on the top of the bridge
-  args.state.player.falling = false if args.state.player.y == args.state.bridge_top
-  args.state.player.rect = [args.state.player.x, args.state.player.y, args.state.player.h, args.state.player.w] # sets definition for player
+    def initialize x, y, w, h
+      @x = x
+      @y = y
+      @w = w
+      @h = h
+    end
 
-  args.state.enemy.x += args.state.enemy.dx # velocity; change in x increases by dx
-  args.state.enemy.y += args.state.enemy.dy # same with y and dy
+    def to_s
+      "RectForTest: #{[x, y, w, h]}"
+    end
+  end
+end
 
-  # ensures that the enemy never goes below the bridge
-  args.state.enemy.y  = args.state.enemy.y.greater(args.state.bridge_top)
+begin :intersect_rect?
+  def test_intersect_rect_point args, assert
+    assert.true! [16, 13].intersect_rect?([13, 12, 4, 4]), "point intersects with rect."
+  end
 
-  # ensures that the enemy never goes too far left (outside the screen's scope)
-  args.state.enemy.x  = args.state.enemy.x.greater(0)
+  def test_intersect_rect args, assert
+    intersecting = primitive_representations(0, 0, 100, 100) +
+                   primitive_representations(20, 20, 20, 20)
 
-  # objects that go up must come down because of gravity
-  args.state.enemy.dy += args.state.gravity
+    intersecting.product(intersecting).each do |rect_one, rect_two|
+      assert.true! rect_one.intersect_rect?(rect_two),
+                   "intersect_rect? assertion failed for #{rect_one}, #{rect_two} (expected true)."
+    end
 
-  args.state.enemy.y  = args.state.enemy.y.greater(args.state.bridge_top)
+    not_intersecting = [
+      [ 0, 0, 5, 5],
+      { x: 10, y: 10, w: 5, h: 5 },
+      RectForTest.new(20, 20, 5, 5)
+    ]
 
-  #sets definition of enemy
-  args.state.enemy.rect = [args.state.enemy.x, args.state.enemy.y, args.state.enemy.h, args.state.enemy.w]
+    not_intersecting.product(not_intersecting)
+      .reject { |rect_one, rect_two| rect_one == rect_two }
+      .each do |rect_one, rect_two|
+      assert.false! rect_one.intersect_rect?(rect_two),
+                    "intersect_rect? assertion failed for #{rect_one}, #{rect_two} (expected false)."
+    end
+  end
+end
 
-  if args.state.enemy.y == args.state.bridge_top # if enemy is located on the top of the bridge
-    args.state.enemy.dy = 0 # there is no change in y
+begin :inside_rect?
+  def assert_inside_rect outer: nil, inner: nil, expected: nil, assert: nil
+    assert.true! inner.inside_rect?(outer) == expected,
+                 "inside_rect? assertion failed for outer: #{outer} inner: #{inner} (expected #{expected})."
   end
 
-  # if 60 frames have passed and the enemy is not moving vertically
-  if args.state.tick_count.mod_zero?(args.state.enemy_jump_interval) && args.state.enemy.dy == 0
-    args.state.enemy.dy = args.state.enemy_jump_power # the enemy jumps up
+  def test_inside_rect args, assert
+    outer_rects = primitive_representations(0, 0, 10, 10)
+    inner_rects = primitive_representations(1, 1, 5, 5)
+    primitive_representations(0, 0, 10, 10).product(primitive_representations(1, 1, 5, 5))
+      .each do |outer, inner|
+      assert_inside_rect outer: outer, inner: inner,
+                         expected: true, assert: assert
+    end
   end
+end
 
-  # if 40 frames have passed or 5 frames have passed since the game ended
-  if args.state.tick_count.mod_zero?(args.state.hammer_throw_interval) || args.state.game_over_at.elapsed_time == 5
-    # rand will return a number greater than or equal to 0 and less than given variable's value (since max is excluded)
-    # that is why we're adding 1, to include the max possibility
-    volley_dx   = (rand(args.state.hammer_launch_power_default) + 1) * -1 # horizontal movement (follow order of operations)
+begin :angle_to
+  def test_angle_to args, assert
+    origins = primitive_representations(0, 0, 0, 0)
+    rights = primitive_representations(1, 0, 0, 0)
+    aboves = primitive_representations(0, 1, 0, 0)
 
-    # if the horizontal distance between the player and enemy is less than 128 pixels
-    if (args.state.player.x - args.state.enemy.x).abs < 128
-      # the change in x won't be that great since the enemy and player are closer to each other
-      volley_dx = (rand(args.state.hammer_launch_power_near) + 1) * -1
-    end
+    origins.product(aboves).each do |origin, above|
+      assert.equal! origin.angle_to(above), 90,
+                    "A point directly above should be 90 degrees."
 
-    # if the horizontal distance between the player and enemy is greater than 300 pixels
-    if (args.state.player.x - args.state.enemy.x).abs > 300
-      # change in x will be more drastic since player and enemy are so far apart
-      volley_dx = (rand(args.state.hammer_launch_power_far) + 1) * -1 # more drastic change
+      assert.equal! above.angle_from(origin), 90,
+                    "A point coming from above should be 90 degrees."
     end
 
-    (rand(args.state.max_hammers_per_volley) + 1).map_with_index do |i|
-      args.state.enemy.hammer_queue << { # stores hammer values in a hash
-        x: args.state.enemy.x,
-        w: args.state.hammer_size,
-        h: args.state.hammer_size,
-        dx: volley_dx, # change in horizontal position
-        # multiplication operator takes precedence over addition operator
-        throw_at: args.state.tick_count + i * args.state.gap_between_hammers
-      }
-    end
-  end
+    origins.product(rights).each do |origin, right|
+      assert.equal! origin.angle_to(right) % 360, 0,
+                    "A point directly to the right should be 0 degrees."
 
-  # add elements from hammer_queue collection to the hammers collection by
-  # finding all hammers that were thrown before the current frame (have already been thrown)
-  args.state.enemy.hammers += args.state.enemy.hammer_queue.find_all do |h|
-    h[:throw_at] < args.state.tick_count
-  end
+      assert.equal! right.angle_from(origin) % 360, 0,
+                    "A point coming from the right should be 0 degrees."
 
-  args.state.enemy.hammers.each do |h| # sets values for all hammers in collection
-    h[:y]  ||= args.state.enemy.y + 130
-    h[:dy] ||= args.state.hammer_upward_launch_power
-    h[:dy]  += args.state.gravity # acceleration is change in gravity
-    h[:x]   += h[:dx] # incremented by change in position
-    h[:y]   += h[:dy]
-    h[:rect] = [h[:x], h[:y], h[:w], h[:h]] # sets definition of hammer's rect
+    end
   end
+end
 
-  # reject hammers that have been thrown before current frame (have already been thrown)
-  args.state.enemy.hammer_queue = args.state.enemy.hammer_queue.reject do |h|
-    h[:throw_at] < args.state.tick_count
-  end
+begin :scale_rect
+  def test_scale_rect args, assert
+    assert.equal! [0, 0, 100, 100].scale_rect(0.5, 0.5),
+                  [25.0, 25.0, 50.0, 50.0]
 
-  # any hammers with a y position less than 0 are rejected from the hammers collection
-  # since they have gone too far down (outside the scope's screen)
-  args.state.enemy.hammers = args.state.enemy.hammers.reject { |h| h[:y] < 0 }
+    assert.equal! [0, 0, 100, 100].scale_rect(0.5),
+                  [0.0, 0.0, 50.0, 50.0]
 
-  # if there are any hammers that intersect with (or hit) the player,
-  # the reset_player method is called (so the game can start over)
-  if args.state.enemy.hammers.any? { |h| h[:rect].intersect_rect?(args.state.player.rect) }
-    reset_player args
+    assert.equal! [0, 0, 100, 100].scale_rect_extended(percentage_x: 0.5, percentage_y: 0.5, anchor_x: 0.5, anchor_y: 0.5),
+                  [25.0, 25.0, 50.0, 50.0]
+
+    assert.equal! [0, 0, 100, 100].scale_rect_extended(percentage_x: 0.5, percentage_y: 0.5, anchor_x: 0, anchor_y: 0),
+                  [0.0, 0.0, 50.0, 50.0]
   end
+end
 
-  # if the enemy's rect intersects with (or hits) the player,
-  # the reset_player method is called (so the game can start over)
-  if args.state.enemy.rect.intersect_rect? args.state.player.rect
-    reset_player args
+$gtk.reset 100
+$gtk.log_level = :off
+
+
+Advanced Debugging - Unit Tests - http_tests.rb
+# ./samples/10_advanced_debugging/03_unit_tests/http_tests.rb
+def try_assert_or_schedule args, assert
+  if $result[:complete]
+    log_info "Request completed! Verifying."
+    if $result[:http_response_code] != 200
+      log_info "The request yielded a result of #{$result[:http_response_code]} instead of 200."
+      exit
+    end
+    log_info ":try_assert_or_schedule succeeded!"
+  else
+    args.gtk.schedule_callback Kernel.tick_count + 10 do
+      try_assert_or_schedule args, assert
+    end
   end
 end
 
-# Resets the player by changing its properties back to the values they had at initialization
-def reset_player args
-  args.state.player.x = 0
-  args.state.player.y = args.state.bridge_top
-  args.state.player.dy = 0
-  args.state.player.dx = 0
-  args.state.enemy.hammers.clear # empties hammer collection
-  args.state.enemy.hammer_queue.clear # empties hammer_queue
-  args.state.game_over_at = args.state.tick_count # game_over_at set to current frame (or passage of time)
+def test_http args, assert
+  $result = $gtk.http_get 'http://dragonruby.org'
+  try_assert_or_schedule args, assert
 end
 
-# Processes input from the user to move the player
-def input args
-  if args.inputs.keyboard.space # if the user presses the space bar
-    args.state.player.jumped_at ||= args.state.tick_count # jumped_at is set to current frame
+$gtk.reset 100
+$gtk.log_level = :off
 
-    # if the time that has passed since the jump is less than the player's jump duration and
-    # the player is not falling
-    if args.state.player.jumped_at.elapsed_time < args.state.player_jump_power_duration && !args.state.player.falling
-      args.state.player.dy = args.state.player_jump_power # change in y is set to power of player's jump
-    end
-  end
+
+Advanced Debugging - Unit Tests - nil_coercion_tests.rb
+# ./samples/10_advanced_debugging/03_unit_tests/nil_coercion_tests.rb
+# numbers
+def test_open_entity_add_number args, assert
+  assert.nil! args.state.i_value
+  args.state.i_value += 5
+  assert.equal! args.state.i_value, 5
 
-  # if the space bar is in the "up" state (or not being pressed down)
-  if args.inputs.keyboard.key_up.space
-    args.state.player.jumped_at = nil # jumped_at is empty
-    args.state.player.falling = true # the player is falling
-  end
+  assert.nil! args.state.f_value
+  args.state.f_value += 5.5
+  assert.equal! args.state.f_value, 5.5
+end
 
-  if args.inputs.keyboard.left # if left key is pressed
-    args.state.player.dx -= args.state.player_acceleration # dx decreases by acceleration (player goes left)
-    # dx is either set to current dx or the negative max run speed (which would be -10),
-    # whichever has a greater value
-    args.state.player.dx = args.state.player.dx.greater(-args.state.player_max_run_speed)
-  elsif args.inputs.keyboard.right # if right key is pressed
-    args.state.player.dx += args.state.player_acceleration # dx increases by acceleration (player goes right)
-    # dx is either set to current dx or max run speed (which would be 10),
-    # whichever has a lesser value
-    args.state.player.dx = args.state.player.dx.lesser(args.state.player_max_run_speed)
-  else
-    args.state.player.dx *= args.state.player_speed_slowdown_rate # dx is scaled down
-  end
+def test_open_entity_subtract_number args, assert
+  assert.nil! args.state.i_value
+  args.state.i_value -= 5
+  assert.equal! args.state.i_value, -5
+
+  assert.nil! args.state.f_value
+  args.state.f_value -= 5.5
+  assert.equal! args.state.f_value, -5.5
 end
 
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.space ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
-  end
+def test_open_entity_multiply_number args, assert
+  assert.nil! args.state.i_value
+  args.state.i_value *= 5
+  assert.equal! args.state.i_value, 0
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+  assert.nil! args.state.f_value
+  args.state.f_value *= 5.5
+  assert.equal! args.state.f_value, 0
 end
 
-

-Physics And Collisions - Entities - main.rb
-# ./samples/04_physics_and_collisions/03_entities/app/main.rb
-=begin
+def test_open_entity_divide_number args, assert
+  assert.nil! args.state.i_value
+  args.state.i_value /= 5
+  assert.equal! args.state.i_value, 0
 
- Reminders:
+  assert.nil! args.state.f_value
+  args.state.f_value /= 5.5
+  assert.equal! args.state.f_value, 0
+end
 
- - map: Ruby method used to transform data; used in arrays, hashes, and collections.
-   Can be used to perform an action on every element of a collection, such as multiplying
-   each element by 2 or declaring every element as a new entity.
+# array
+def test_open_entity_add_array args, assert
+  assert.nil! args.state.values
+  args.state.values += [:a, :b, :c]
+  assert.equal! args.state.values, [:a, :b, :c]
+end
 
- - reject: Removes elements from a collection if they meet certain requirements.
-   For example, you can derive an array of odd numbers from an original array of
-   numbers 1 through 10 by rejecting all elements that are even (or divisible by 2).
+def test_open_entity_subtract_array args, assert
+  assert.nil! args.state.values
+  args.state.values -= [:a, :b, :c]
+  assert.equal! args.state.values, []
+end
 
- - args.state.new_entity: Used when we want to create a new object, like a sprite or button.
-   In this sample app, new_entity is used to define the properties of enemies and bullets.
-   (Remember, you can use state to define ANY property and it will be retained across frames.)
+def test_open_entity_shovel_array args, assert
+  assert.nil! args.state.values
+  args.state.values << :a
+  assert.equal! args.state.values, [:a]
+end
 
- - args.outputs.labels: An array. The values generate a label on the screen.
-   The parameters are [X, Y, TEXT, SIZE, ALIGN, RED, GREEN, BLUE, ALPHA, FONT STYLE]
+def test_open_entity_enumerate args, assert
+  assert.nil! args.state.values
+  args.state.values = args.state.values.map_with_index { |i| i }
+  assert.equal! args.state.values, []
 
- - ARRAY#intersect_rect?: Returns true or false depending on if the two rectangles intersect.
+  assert.nil! args.state.values_2
+  args.state.values_2 = args.state.values_2.map { |i| i }
+  assert.equal! args.state.values_2, []
 
- - args.inputs.mouse.click.point.(x|y): The x and y location of the mouse.
+  assert.nil! args.state.values_3
+  args.state.values_3 = args.state.values_3.flat_map { |i| i }
+  assert.equal! args.state.values_3, []
+end
 
-=end
+# hashes
+def test_open_entity_indexer args, assert
+  GTK::Entity.__reset_id__!
+  assert.nil! args.state.values
+  args.state.values[:test] = :value
+  assert.equal! args.state.values.to_s, { entity_id: 1, entity_name: :values, entity_keys_by_ref: {}, test: :value }.to_s
+end
 
-# This sample app shows enemies that contain an id value and the time they were created.
-# These enemies can be removed by shooting at them with bullets.
+# bug
+def test_open_entity_nil_bug args, assert
+  GTK::Entity.__reset_id__!
+  args.state.foo.a
+  args.state.foo.b
+  @hello[:foobar]
+  assert.nil! args.state.foo.a, "a was not nil."
+  # the line below fails
+  # assert.nil! args.state.foo.b, "b was not nil."
+end
 
-# Calls all methods necessary for the game to function properly.
-def tick args
-  tick_instructions args, "Sample app shows how to use args.state.new_entity along with collisions. CLICK to shoot a bullet."
-  defaults args
-  render args
-  calc args
-  process_inputs args
+
+Advanced Debugging - Unit Tests - object_to_primitive_tests.rb
+# ./samples/10_advanced_debugging/03_unit_tests/object_to_primitive_tests.rb
+class PlayerSpriteForTest
 end
 
-# Sets default values
-# Enemies and bullets start off as empty collections
-def defaults args
-  args.state.enemies ||= []
-  args.state.bullets ||= []
+def test_array_to_sprite args, assert
+  array = [[0, 0, 100, 100, "test.png"]].sprites
+  puts "No exception was thrown. Sweet!"
 end
 
-# Provides each enemy in enemies collection with rectangular border,
-# as well as a label showing id and when they were created
-def render args
-  # When you're calling a method that takes no arguments, you can use this & syntax on map.
-  # Numbers are being added to x and y in order to keep the text within the enemy's borders.
-  args.outputs.borders << args.state.enemies.map(&:rect)
-  args.outputs.labels  << args.state.enemies.flat_map do |enemy|
-    [
-      [enemy.x + 4, enemy.y + 29, "id: #{enemy.entity_id}", -3, 0],
-      [enemy.x + 4, enemy.y + 17, "created_at: #{enemy.created_at}", -3, 0] # frame enemy was created
-    ]
-  end
+def test_class_to_sprite args, assert
+  array = [PlayerSprite.new].sprites
+  assert.true! array.first.is_a?(PlayerSprite)
+  puts "No exception was thrown. Sweet!"
+end
 
-  # Outputs bullets in bullets collection as rectangular solids
-  args.outputs.solids << args.state.bullets.map(&:rect)
+$gtk.reset 100
+$gtk.log_level = :off
+
+
+Advanced Debugging - Unit Tests - parsing_tests.rb
+# ./samples/10_advanced_debugging/03_unit_tests/parsing_tests.rb
+def test_parse_json args, assert
+  result = args.gtk.parse_json '{ "name": "John Doe", "aliases": ["JD"] }'
+  assert.equal! result, { "name"=>"John Doe", "aliases"=>["JD"] }, "Parsing JSON failed."
 end
 
-# Calls all methods necessary for performing calculations
-def calc args
-  add_new_enemies_if_needed args
-  move_bullets args
-  calculate_collisions args
-  remove_bullets_of_screen args
+def test_parse_xml args, assert
+  result = args.gtk.parse_xml <<-S
+
+  John Doe
+
+S
+
+ expected = {:type=>:element,
+             :name=>nil,
+             :children=>[{:type=>:element,
+                          :name=>"Person",
+                          :children=>[{:type=>:element,
+                                       :name=>"Name",
+                                       :children=>[{:type=>:content,
+                                                    :data=>"John Doe"}]}],
+                          :attributes=>{"id"=>"100"}}]}
+
+ assert.equal! result, expected, "Parsing xml failed."
 end
 
-# Adds enemies to the enemies collection and sets their values
-def add_new_enemies_if_needed args
-  return if args.state.enemies.length >= 10 # if 10 or more enemies, enemies are not added
-  return unless args.state.bullets.length == 0 # if user has not yet shot bullet, no enemies are added
+$gtk.reset 100
+$gtk.log_level = :off
 
-  args.state.enemies += (10 - args.state.enemies.length).map do # adds enemies so there are 10 total
-    args.state.new_entity(:enemy) do |e| # each enemy is declared as a new entity
-      e.x = 640 + 500 * rand # each enemy is given random position on screen
-      e.y = 600 * rand + 50
-      e.rect = [e.x, e.y, 130, 30] # sets definition for enemy's rect
-    end
-  end
+
+Advanced Debugging - Unit Tests - require_tests.rb
+# ./samples/10_advanced_debugging/03_unit_tests/require_tests.rb
+def write_src path, src
+  $gtk.write_file path, src
 end
 
-# Moves bullets across screen
-# Sets definition of the bullets
-def move_bullets args
-  args.state.bullets.each do |bullet| # perform action on each bullet in collection
-    bullet.x += bullet.speed # increment x by speed (bullets fly horizontally across screen)
+write_src 'app/unit_testing_game.rb', <<-S
+module UnitTesting
+  class Game
+  end
+end
+S
 
-    # By randomizing the value that increments bullet.y, the bullet does not fly straight up and out
-    # of the scope of the screen. Try removing what follows bullet.speed, or changing 0.25 to 1.25 to
-    # see what happens to the bullet's movement.
-    bullet.y += bullet.speed.*(0.25).randomize(:ratio, :sign)
-    bullet.rect = [bullet.x, bullet.y, bullet.size, bullet.size] # sets definition of bullet's rect
+write_src 'lib/unit_testing_lib.rb', <<-S
+module UnitTesting
+  class Lib
   end
 end
+S
 
-# Determines if a bullet hits an enemy
-def calculate_collisions args
-  args.state.bullets.each do |bullet| # perform action on every bullet and enemy in collections
-    args.state.enemies.each do |enemy|
-      # if bullet has not exploded yet and the bullet hits an enemy
-      if !bullet.exploded && bullet.rect.intersect_rect?(enemy.rect)
-        bullet.exploded = true # bullet explodes
-        enemy.dead = true # enemy is killed
-      end
-    end
+write_src 'app/nested/unit_testing_nested.rb', <<-S
+module UnitTesting
+  class Nested
   end
+end
+S
 
-  # All exploded bullets are rejected or removed from the bullets collection
-  # and any dead enemy is rejected from the enemies collection.
-  args.state.bullets = args.state.bullets.reject(&:exploded)
-  args.state.enemies = args.state.enemies.reject(&:dead)
+require 'app/unit_testing_game.rb'
+require 'app/nested/unit_testing_nested.rb'
+require 'lib/unit_testing_lib.rb'
+
+def test_require args, assert
+  UnitTesting::Game.new
+  UnitTesting::Lib.new
+  UnitTesting::Nested.new
+  $gtk.exec 'rm ./mygame/app/unit_testing_game.rb'
+  $gtk.exec 'rm ./mygame/app/nested/unit_testing_nested.rb'
+  $gtk.exec 'rm ./mygame/lib/unit_testing_lib.rb'
+  assert.ok!
 end
 
-# Bullets are rejected from bullets collection once their position exceeds the width of screen
-def remove_bullets_of_screen args
-  args.state.bullets = args.state.bullets.reject { |bullet| bullet.x > 1280 } # screen width is 1280
+
+Advanced Debugging - Unit Tests - serialize_deserialize_tests.rb
+# ./samples/10_advanced_debugging/03_unit_tests/serialize_deserialize_tests.rb
+def test_serialize args, assert
+  GTK::Entity.__reset_id__!
+  args.state.player_one = "test"
+  result = args.gtk.serialize_state args.state
+  assert.equal! result, "{:entity_id=>3, :entity_keys_by_ref=>{}, :tick_count=>-1, :player_one=>\"test\"}"
+
+  GTK::Entity.__reset_id__!
+  args.gtk.write_file 'state.txt', ''
+  result = args.gtk.serialize_state 'state.txt', args.state
+  assert.equal! result, "{:entity_id=>3, :entity_keys_by_ref=>{}, :tick_count=>-1, :player_one=>\"test\"}"
 end
 
-# Calls fire_bullet method
-def process_inputs args
-  fire_bullet args
+def test_deserialize args, assert
+  GTK::Entity.__reset_id__!
+  result = args.gtk.deserialize_state '{:entity_id=>3, :tick_count=>-1, :player_one=>"test"}'
+  assert.equal! result.player_one, "test"
+
+  GTK::Entity.__reset_id__!
+  args.gtk.write_file 'state.txt',  '{:entity_id=>3, :tick_count=>-1, :player_one=>"test"}'
+  result = args.gtk.deserialize_state 'state.txt'
+  assert.equal! result.player_one, "test"
 end
 
-# Once mouse is clicked by the user to fire a bullet, a new bullet is added to bullets collection
-def fire_bullet args
-  return unless args.inputs.mouse.click # return unless mouse is clicked
-  args.state.bullets << args.state.new_entity(:bullet) do |bullet| # new bullet is declared a new entity
-    bullet.y = args.inputs.mouse.click.point.y # set to the y value of where the mouse was clicked
-    bullet.x = 0 # starts on the left side of the screen
-    bullet.size = 10
-    bullet.speed = 10 * rand + 2 # speed of a bullet is randomized
-    bullet.rect = [bullet.x, bullet.y, bullet.size, bullet.size] # definition is set
+def test_very_large_serialization args, assert
+  GTK::Entity.__reset_id__!
+  size = 3000
+  size.map_with_index do |i|
+    args.state.send("k#{i}=".to_sym, i)
   end
+
+  result = args.gtk.serialize_state args.state
+  assert.true! (args.gtk.console.log.join.include? "unlikely a string this large will deserialize correctly")
 end
 
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.space ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
-  end
+def test_strict_entity_serialization args, assert
+  GTK::Entity.__reset_id__!
+  args.state.player_one = args.state.new_entity(:player, name: "Ryu")
+  args.state.player_two = args.state.new_entity_strict(:player_strict, name: "Ken")
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+  serialized_state = args.gtk.serialize_state args.state
+  assert.equal! serialized_state, '{:entity_id=>1, :entity_keys_by_ref=>{}, :tick_count=>-1, :player_one=>{:entity_id=>1, :entity_name=>:player, :entity_keys_by_ref=>{}, :entity_type=>:player, :created_at=>-1, :global_created_at=>-1, :name=>"Ryu"}, :player_two=>{:entity_id=>3, :entity_name=>:player_strict, :entity_type=>:player_strict, :created_at=>-1, :global_created_at_elapsed=>-1, :entity_strict=>true, :entity_keys_by_ref=>{:entity_type=>:entity_name, :global_created_at_elapsed=>:created_at}, :name=>"Ken"}}'
+
+  GTK::Entity.__reset_id__!
+  deserialize_state = args.gtk.deserialize_state serialized_state
+
+  assert.equal! args.state.player_one.name, deserialize_state.player_one.name
+  assert.true! args.state.player_one.is_a? GTK::OpenEntity
+
+  assert.equal! args.state.player_two.name, deserialize_state.player_two.name
+  assert.true! args.state.player_two.is_a? GTK::StrictEntity
 end
 
-

-Physics And Collisions - Box Collision - main.rb
-# ./samples/04_physics_and_collisions/04_box_collision/app/main.rb
-=begin
+def test_strict_entity_serialization_with_nil args, assert
+  GTK::Entity.__reset_id__!
+  args.state.player_one = args.state.new_entity(:player, name: "Ryu")
+  args.state.player_two = args.state.new_entity_strict(:player_strict, name: "Ken", blood_type: nil)
 
- APIs listing that haven't been encountered in previous sample apps:
+  serialized_state = args.gtk.serialize_state args.state
+  assert.equal! serialized_state, '{:entity_id=>9, :entity_keys_by_ref=>{}, :tick_count=>-1, :player_one=>{:entity_id=>1, :entity_name=>:player, :entity_keys_by_ref=>{}, :entity_type=>:player, :created_at=>-1, :global_created_at=>-1, :name=>"Ryu"}, :player_two=>{:entity_id=>2, :entity_name=>:player_strict, :entity_type=>:player_strict, :created_at=>-1, :global_created_at_elapsed=>-1, :entity_strict=>true, :entity_keys_by_ref=>{:entity_type=>:entity_name, :global_created_at_elapsed=>:created_at}, :name=>"Ken", :blood_type=>nil}}'
 
- - first: Returns the first element of the array.
-   For example, if we have an array
-   numbers = [1, 2, 3, 4, 5]
-   and we call first by saying
-   numbers.first
-   the number 1 will be returned because it is the first element of the numbers array.
+  GTK::Entity.__reset_id__!
+  deserialized_state = args.gtk.deserialize_state serialized_state
 
- - num1.idiv(num2): Divides two numbers and returns an integer.
-   For example,
-   16.idiv(3) = 5, because 16 / 3 is 5.33333 returned as an integer.
-   16.idiv(4) = 4, because 16 / 4 is 4 and already has no decimal.
+  assert.equal! args.state.player_one.name, deserialized_state.player_one.name
+  assert.true! args.state.player_one.is_a? GTK::OpenEntity
 
- Reminders:
+  assert.equal! args.state.player_two.name, deserialized_state.player_two.name
+  assert.equal! args.state.player_two.blood_type, deserialized_state.player_two.blood_type
+  assert.equal! deserialized_state.player_two.blood_type, nil
+  assert.true! args.state.player_two.is_a? GTK::StrictEntity
 
- - find_all: Finds all values that satisfy specific requirements.
+  deserialized_state.player_two.blood_type = :O
+  assert.equal! deserialized_state.player_two.blood_type, :O
+end
 
- - ARRAY#intersect_rect?: An array with at least four values is
-   considered a rect. The intersect_rect? function returns true
-   or false depending on if the two rectangles intersect.
+def test_multiple_strict_entities args, assert
+  GTK::Entity.__reset_id__!
+  args.state.player = args.state.new_entity_strict(:player_one, name: "Ryu")
+  args.state.enemy = args.state.new_entity_strict(:enemy, name: "Bison", other_property: 'extra mean')
 
- - reject: Removes elements from a collection if they meet certain requirements.
+  serialized_state = args.gtk.serialize_state args.state
 
-=end
+  GTK::Entity.__reset_id__!
+  deserialized_state = args.gtk.deserialize_state serialized_state
 
-# This sample app allows users to create tiles and place them anywhere on the screen as obstacles.
-# The player can then move and maneuver around them.
+  assert.equal! deserialized_state.player.name, "Ryu"
+  assert.equal! deserialized_state.enemy.other_property, "extra mean"
+end
 
-class PoorManPlatformerPhysics
-  attr_accessor :grid, :inputs, :state, :outputs
+def test_by_reference_state args, assert
+  GTK::Entity.__reset_id__!
+  args.state.a = { name: "Jane Doe" }
+  args.state.b = args.state.a
+  assert.equal! args.state.a.object_id, args.state.b.object_id
+  serialized_state = args.gtk.serialize_state args.state
 
-  # Calls all methods necessary for the app to run successfully.
-  def tick
-    defaults
-    render
-    calc
-    process_inputs
+  GTK::Entity.__reset_id__!
+  deserialized_state = args.gtk.deserialize_state serialized_state
+  assert.equal! deserialized_state.a.object_id, deserialized_state.b.object_id
+end
+
+def test_by_reference_state_strict_entities args, assert
+  GTK::Entity.__reset_id__!
+  args.state.a = { name: "Jane Doe" }
+  args.state.strict_entity = args.state.new_entity_strict(:couple) do |e|
+    e.one = args.state.new_entity_strict(:person, name: "Jane")
+    e.two = e.one
   end
+  assert.equal! args.state.strict_entity.one, args.state.strict_entity.two
+  serialized_state = args.gtk.serialize_state args.state
 
-  # Sets default values for variables.
-  # The ||= sign means that the variable will only be set to the value following the = sign if the value has
-  # not already been set before. Intialization happens only in the first frame.
-  def defaults
-    state.tile_size               = 64
-    state.gravity                 = -0.2
-    state.previous_tile_size    ||= state.tile_size
-    state.x                     ||= 0
-    state.y                     ||= 800
-    state.dy                    ||= 0
-    state.dx                    ||= 0
-    state.world                 ||= []
-    state.world_lookup          ||= {}
-    state.world_collision_rects ||= []
+  GTK::Entity.__reset_id__!
+  deserialized_state = args.gtk.deserialize_state serialized_state
+  assert.equal! deserialized_state.strict_entity.one, deserialized_state.strict_entity.two
+end
+
+
+Advanced Debugging - Unit Tests - state_serialization_experimental_tests.rb
+# ./samples/10_advanced_debugging/03_unit_tests/state_serialization_experimental_tests.rb
+MAX_CODE_GEN_LENGTH = 50
+
+# NOTE: This is experimental/advanced stuff.
+def needs_partitioning? target
+  target[:value].to_s.length > MAX_CODE_GEN_LENGTH
+end
+
+def partition target
+  return [] unless needs_partitioning? target
+  if target[:value].is_a? GTK::OpenEntity
+    target[:value] = target[:value].hash
   end
 
-  # Outputs solids and borders of different colors for the world and collision_rects collections.
-  def render
+  results = []
+  idx = 0
+  left, right = target[:value].partition do
+    idx += 1
+    idx.even?
+  end
+  left, right = Hash[left], Hash[right]
+  left = { value: left }
+  right = { value: right}
+  [left, right]
+end
+
+def add_partition target, path, aggregate, final_result
+  partitions = partition target
+  partitions.each do |part|
+    if needs_partitioning? part
+      if part[:value].keys.length == 1
+        first_key = part[:value].keys[0]
+        new_part = { value: part[:value][first_key] }
+        path.push first_key
+        add_partition new_part, path, aggregate, final_result
+        path.pop
+      else
+        add_partition part, path, aggregate, final_result
+      end
+    else
+      final_result << { value: { __path__: [*path] } }
+      final_result << { value: part[:value] }
+    end
+  end
+end
+
+def state_to_string state
+  parts_queue = []
+  final_queue = []
+  add_partition({ value: state.hash },
+                [],
+                parts_queue,
+                final_queue)
+  final_queue.reject {|i| i[:value].keys.length == 0}.map do |i|
+    i[:value].to_s
+  end.join("\n#==================================================#\n")
+end
 
-    # Sets a black background on the screen (Comment this line out and the background will become white.)
-    # Also note that black is the default color for when no color is assigned.
-    outputs.solids << grid.rect
+def state_from_string string
+  Kernel.eval("$load_data = {}")
+  lines = string.split("\n#==================================================#\n")
+  lines.each do |l|
+    puts "todo: #{l}"
+  end
 
-    # The position, size, and color (white) are set for borders given to the world collection.
-    # Try changing the color by assigning different numbers (between 0 and 255) to the last three parameters.
-    outputs.borders << state.world.map do |x, y|
-      [x * state.tile_size,
-       y * state.tile_size,
-       state.tile_size,
-       state.tile_size, 255, 255, 255]
-    end
+  GTK::OpenEntity.parse_from_hash $load_data
+end
 
-    # The top, bottom, and sides of the borders for collision_rects are different colors.
-    outputs.borders << state.world_collision_rects.map do |e|
-      [
-        [e[:top],                             0, 170,   0], # top is a shade of green
-        [e[:bottom],                          0, 100, 170], # bottom is a shade of greenish-blue
-        [e[:left_right],                    170,   0,   0], # left and right are a shade of red
-      ]
-    end
+def test_save_and_load args, assert
+  args.state.item_1.name = "Jane"
+  string = state_to_string args.state
+  state = state_from_string string
+  assert.equal! args.state.item_1.name, state.item_1.name
+end
 
-    # Sets the position, size, and color (a shade of green) of the borders of only the player's
-    # box and outputs it. If you change the 180 to 0, the player's box will be black and you
-    # won't be able to see it (because it will match the black background).
-    outputs.borders << [state.x,
-                        state.y,
-                        state.tile_size,
-                        state.tile_size,  0, 180, 0]
+def test_save_and_load_big args, assert
+  size = 1000
+  size.map_with_index do |i|
+    args.state.send("k#{i}=".to_sym, i)
   end
 
-  # Calls methods needed to perform calculations.
-  def calc
-    calc_world_lookup
-    calc_player
+  string = state_to_string args.state
+  state = state_from_string string
+  size.map_with_index do |i|
+    assert.equal! args.state.send("k#{i}".to_sym), state.send("k#{i}".to_sym)
+    assert.equal! args.state.send("k#{i}".to_sym), i
+    assert.equal! state.send("k#{i}".to_sym), i
   end
+end
 
-  # Performs calculations on world_lookup and sets values.
-  def calc_world_lookup
+def test_save_and_load_big_nested args, assert
+  args.state.player_one.friend.nested_hash.k0 = 0
+  args.state.player_one.friend.nested_hash.k1 = 1
+  args.state.player_one.friend.nested_hash.k2 = 2
+  args.state.player_one.friend.nested_hash.k3 = 3
+  args.state.player_one.friend.nested_hash.k4 = 4
+  args.state.player_one.friend.nested_hash.k5 = 5
+  args.state.player_one.friend.nested_hash.k6 = 6
+  args.state.player_one.friend.nested_hash.k7 = 7
+  args.state.player_one.friend.nested_hash.k8 = 8
+  args.state.player_one.friend.nested_hash.k9 = 9
+  string = state_to_string args.state
+  state = state_from_string string
+end
 
-    # If the tile size isn't equal to the previous tile size,
-    # the previous tile size is set to the tile size,
-    # and world_lookup hash is set to empty.
-    if state.tile_size != state.previous_tile_size
-      state.previous_tile_size = state.tile_size
-      state.world_lookup = {} # empty hash
-    end
+$gtk.reset 100
+$gtk.log_level = :off
 
-    # return if the world_lookup hash has keys (or, in other words, is not empty)
-    # return unless the world collection has values inside of it (or is not empty)
-    return if state.world_lookup.keys.length > 0
-    return unless state.world.length > 0
+
+Advanced Debugging - Unit Tests - suggest_autocompletion_tests.rb
+# ./samples/10_advanced_debugging/03_unit_tests/suggest_autocompletion_tests.rb
+def default_suggest_autocompletion args
+  {
+    index: 4,
+    text: "args.",
+    __meta__: {
+      other_options: [
+        {
+          index: Fixnum,
+          file: "app/main.rb"
+        }
+      ]
+    }
+  }
+end
 
-    # Starts with an empty hash for world_lookup.
-    # Searches through the world and finds the coordinates that exist.
-    state.world_lookup = {}
-    state.world.each { |x, y| state.world_lookup[[x, y]] = true }
+def assert_completion source, *expected
+  results = suggest_autocompletion text:  (source.strip.gsub  ":cursor", ""),
+                                   index: (source.strip.index ":cursor")
 
-    # Assigns world_collision_rects for every sprite drawn.
-    state.world_collision_rects =
-      state.world_lookup
-          .keys
-          .map do |coord_x, coord_y|
-            s = state.tile_size
-            # multiply by tile size so the grid coordinates; sets pixel value
-            # don't forget that position is denoted by bottom left corner
-            # set x = coord_x or y = coord_y and see what happens!
-            x = s * coord_x
-            y = s * coord_y
-            {
-              # The values added to x, y, and s position the world_collision_rects so they all appear
-              # stacked (on top of world rects) but don't directly overlap.
-              # Remove these added values and mess around with the rect placement!
-              args:       [coord_x, coord_y],
-              left_right: [x,     y + 4, s,     s - 6], # hash keys and values
-              top:        [x + 4, y + 6, s - 8, s - 6],
-              bottom:     [x + 1, y - 1, s - 2, s - 8],
-            }
-          end
-  end
+  puts results
+end
 
-  # Performs calculations to change the x and y values of the player's box.
-  def calc_player
+def test_args_completion args, assert
+  $gtk.write_file_root "autocomplete.txt", ($gtk.suggest_autocompletion text: <<-S, index: 128).join("\n")
+require 'app/game.rb'
 
-    # Since acceleration is the change in velocity, the change in y (dy) increases every frame.
-    # What goes up must come down because of gravity.
-    state.dy += state.gravity
+def tick args
+  args.gtk.suppress_mailbox = false
+  $game ||= Game.new
+  $game.args = args
+  $game.args.
+  $game.tick
+end
+S
 
-    # Calls the calc_box_collision and calc_edge_collision methods.
-    calc_box_collision
-    calc_edge_collision
+  puts "contents:"
+  puts ($gtk.read_file "autocomplete.txt")
+end
 
-    # Since velocity is the change in position, the change in y increases by dy. Same with x and dx.
-    state.y += state.dy
-    state.x += state.dx
+
+Http - Retrieve Images - main.rb
+# ./samples/11_http/01_retrieve_images/app/main.rb
+def tick args
+  args.outputs.background_color = [0, 0, 0]
 
-    # Scales dx down.
-    state.dx *= 0.8
+  # Show a warning at the start.
+  args.state.warning_debounce ||= 11 * 60
+  if args.state.warning_debounce > 0
+    args.state.warning_debounce -= 1
+    args.outputs.labels << [640, 600, "This app shows random images from the Internet.", 10, 1, 255, 255, 255]
+    args.outputs.labels << [640, 500, "Quit in the next few seconds if this is a problem.", 10, 1, 255, 255, 255]
+    args.outputs.labels << [640, 350, "#{(args.state.warning_debounce / 60.0).to_i}", 10, 1, 255, 255, 255]
+    return
   end
 
-  # Calls methods needed to determine collisions between player and world_collision rects.
-  def calc_box_collision
-    return unless state.world_lookup.keys.length > 0 # return unless hash has atleast 1 key
-    collision_floor!
-    collision_left!
-    collision_right!
-    collision_ceiling!
+  args.state.download_debounce ||= 0   # start immediately, reset to non zero later.
+  args.state.photos ||= []
+
+  # Put a little pause between each download.
+  if args.state.download.nil?
+    if args.state.download_debounce > 0
+      args.state.download_debounce -= 1
+    else
+      args.state.download = $gtk.http_get 'https://picsum.photos/200/300.jpg'
+    end
   end
 
-  # Finds collisions between the bottom of the player's rect and the top of a world_collision_rect.
-  def collision_floor!
-    return unless state.dy <= 0 # return unless player is going down or is as far down as possible
-    player_rect = [state.x, state.y - 0.1, state.tile_size, state.tile_size] # definition of player
+  if !args.state.download.nil?
+    if args.state.download[:complete]
+      if args.state.download[:http_response_code] == 200
+        fname = "sprites/#{args.state.photos.length}.jpg"
+        $gtk.write_file fname, args.state.download[:response_data]
+        args.state.photos << [ 100 + rand(1080), 500 - rand(480), fname, rand(80) - 40 ]
+      end
+      args.state.download = nil
+      args.state.download_debounce = (rand(3) + 2) * 60
+    end
+  end
 
-    # Goes through world_collision_rects to find all intersections between the bottom of player's rect and
-    # the top of a world_collision_rect (hence the "-0.1" above)
-    floor_collisions = state.world_collision_rects
-                           .find_all { |r| r[:top].intersect_rect?(player_rect, collision_tollerance) }
-                           .first
+  # draw any downloaded photos...
+  args.state.photos.each { |i|
+    args.outputs.primitives << [i[0], i[1], 200, 300, i[2], i[3]].sprite
+  }
 
-    return unless floor_collisions # return unless collision occurred
-    state.y = floor_collisions[:top].top # player's y is set to the y of the top of the collided rect
-    state.dy = 0 # if a collision occurred, the player's rect isn't moving because its path is blocked
+  # Draw a download progress bar...
+  args.outputs.primitives << [0, 0, 1280, 30, 0, 0, 0, 255].solid
+  if !args.state.download.nil?
+    br = args.state.download[:response_read]
+    total = args.state.download[:response_total]
+    if total != 0
+      pct = br.to_f / total.to_f
+      args.outputs.primitives << [0, 0, 1280 * pct, 30, 0, 0, 255, 255].solid
+    end
   end
+end
 
-  # Finds collisions between the player's left side and the right side of a world_collision_rect.
-  def collision_left!
-    return unless state.dx < 0 # return unless player is moving left
-    player_rect = [state.x - 0.1, state.y, state.tile_size, state.tile_size]
+
+Http - Web Server - main.rb
+# ./samples/11_http/02_web_server/app/main.rb
+def tick args
+  args.state.port ||= 3000
+  # by default the embedded webserver runs on port 9001 (the port number is over 9000) and is disabled in a production build
+  # to enable the http server in a production build, you need to manually start
+  # the server up:
+  args.gtk.start_server! port: args.state.port, enable_in_prod: true
+  args.outputs.background_color = [0, 0, 0]
+  args.outputs.labels << [640, 600, "Point your web browser at http://localhost:#{args.state.port}/", 10, 1, 255, 255, 255]
+
+  args.inputs.http_requests.each { |req|
+    puts("METHOD: #{req.method}");
+    puts("URI: #{req.uri}");
+    puts("HEADERS:");
+    req.headers.each { |k,v| puts("  #{k}: #{v}") }
+
+    if (req.uri == '/')
+      # headers and body can be nil if you don't care about them.
+      # If you don't set the Content-Type, it will default to
+      #  "text/html; charset=utf-8".
+      # Don't set Content-Length; we'll ignore it and calculate it for you
+      args.state.reqnum += 1
+      req.respond 200, "helloThis #{req.method} was request number #{args.state.reqnum}!\n", { 'X-DRGTK-header' => 'Powered by DragonRuby!' }
+    else
+      req.reject
+    end
+  }
+end
 
-    # Goes through world_collision_rects to find all intersections beween the player's left side and the
-    # right side of a world_collision_rect.
-    left_side_collisions = state.world_collision_rects
-                               .find_all { |r| r[:left_right].intersect_rect?(player_rect, collision_tollerance) }
-                               .first
+
+C Extensions - Basics - main.rb
+# ./samples/12_c_extensions/01_basics/app/main.rb
+$gtk.ffi_misc.gtk_dlopen("ext")
+include FFI::CExt
 
-    return unless left_side_collisions # return unless collision occurred
+def tick args
+  args.outputs.labels  << [640, 500, "mouse.x = #{args.mouse.x.to_i}", 5, 1]
+  args.outputs.labels  << [640, 460, "square(mouse.x) = #{square(args.mouse.x.to_i)}", 5, 1]
+  args.outputs.labels  << [640, 420, "mouse.y = #{args.mouse.y.to_i}", 5, 1]
+  args.outputs.labels  << [640, 380, "square(mouse.y) = #{square(args.mouse.y.to_i)}", 5, 1]
+end
 
-    # player's x is set to the value of the x of the collided rect's right side
-    state.x = left_side_collisions[:left_right].right
-    state.dx = 0 # player isn't moving left because its path is blocked
-  end
 
-  # Finds collisions between the right side of the player and the left side of a world_collision_rect.
-  def collision_right!
-    return unless state.dx > 0 # return unless player is moving right
-    player_rect = [state.x + 0.1, state.y, state.tile_size, state.tile_size]
+
+C Extensions - Intermediate - main.rb
+# ./samples/12_c_extensions/02_intermediate/app/main.rb
+$gtk.ffi_misc.gtk_dlopen("ext")
+include FFI::RE
+
+def split_words(input)
+  words = []
+  last = IntPointer.new
+  re = re_compile("\\w+")
+  first = re_matchp(re, input, last)
+  while first != -1
+    words << input.slice(first, last.value)
+    input = input.slice(last.value + first, input.length)
+    first = re_matchp(re, input, last)
+  end
+  words
+end
 
-    # Goes through world_collision_rects to find all intersections between the player's right side
-    # and the left side of a world_collision_rect (hence the "+0.1" above)
-    right_side_collisions = state.world_collision_rects
-                                .find_all { |r| r[:left_right].intersect_rect?(player_rect, collision_tollerance) }
-                                .first
+def tick args
+  args.outputs.labels  << [640, 500, split_words("hello, dragonriders!").join(' '), 5, 1]
+end
 
-    return unless right_side_collisions # return unless collision occurred
+
+C Extensions - Native Pixel Arrays - main.rb
+# ./samples/12_c_extensions/03_native_pixel_arrays/app/main.rb
+$gtk.ffi_misc.gtk_dlopen("ext")
+include FFI::CExt
 
-    # player's x is set to the value of the collided rect's left, minus the size of a rect
-    # tile size is subtracted because player's position is denoted by bottom left corner
-    state.x = right_side_collisions[:left_right].left - state.tile_size
-    state.dx = 0 # player isn't moving right because its path is blocked
-  end
+def tick args
+  args.state.rotation ||= 0
 
-  # Finds collisions between the top of the player's rect and the bottom of a world_collision_rect.
-  def collision_ceiling!
-    return unless state.dy > 0 # return unless player is moving up
-    player_rect = [state.x, state.y + 0.1, state.tile_size, state.tile_size]
+  update_scanner_texture   # this calls into a C extension!
 
-    # Goes through world_collision_rects to find intersections between the bottom of a
-    # world_collision_rect and the top of the player's rect (hence the "+0.1" above)
-    ceil_collisions = state.world_collision_rects
-                          .find_all { |r| r[:bottom].intersect_rect?(player_rect, collision_tollerance) }
-                          .first
+  # New/changed pixel arrays get uploaded to the GPU before we render
+  #  anything. At that point, they can be scaled, rotated, and otherwise
+  #  used like any other sprite.
+  w = 100
+  h = 100
+  x = (1280 - w) / 2
+  y = (720 - h) / 2
+  args.outputs.background_color = [64, 0, 128]
+  args.outputs.primitives << [x, y, w, h, :scanner, args.state.rotation].sprite
+  args.state.rotation += 1
 
-    return unless ceil_collisions # return unless collision occurred
+  args.outputs.primitives << args.gtk.current_framerate_primitives
+end
 
-    # player's y is set to the bottom y of the rect it collided with, minus the size of a rect
-    state.y = ceil_collisions[:bottom].y - state.tile_size
-    state.dy = 0 # if a collision occurred, the player isn't moving up because its path is blocked
-  end
 
-  # Makes sure the player remains within the screen's dimensions.
-  def calc_edge_collision
+
+Path Finding Algorithms - Breadth First Search - main.rb
+# ./samples/13_path_finding_algorithms/01_breadth_first_search/app/main.rb
+# A visual demonstration of a breadth first search
+# Inspired by https://www.redblobgames.com/pathfinding/a-star/introduction.html
 
-    #Ensures that the player doesn't fall below the map.
-    if state.y < 0
-      state.y = 0
-      state.dy = 0
+# An animation that can respond to user input in real time
 
-    #Ensures that the player doesn't go too high.
-    # Position of player is denoted by bottom left hand corner, which is why we have to subtract the
-    # size of the player's box (so it remains visible on the screen)
-    elsif state.y > 720 - state.tile_size # if the player's y position exceeds the height of screen
-      state.y = 720 - state.tile_size # the player will remain as high as possible while staying on screen
-      state.dy = 0
-    end
+# A breadth first search expands in all directions one step at a time
+# The frontier is a queue of cells to be expanded from
+# The visited hash allows quick lookups of cells that have been expanded from
+# The walls hash allows quick lookup of whether a cell is a wall
 
-    # Ensures that the player remains in the horizontal range that it is supposed to.
-    if state.x >= 1280 - state.tile_size && state.dx > 0 # if player moves too far right
-      state.x = 1280 - state.tile_size # player will remain as right as possible while staying on screen
-      state.dx = 0
-    elsif state.x <= 0 && state.dx < 0 # if player moves too far left
-      state.x = 0 # player will remain as left as possible while remaining on screen
-      state.dx = 0
-    end
-  end
+# The breadth first search starts by adding the red star to the frontier array
+# and marking it as visited
+# Each step a cell is removed from the front of the frontier array (queue)
+# Unless the neighbor is a wall or visited, it is added to the frontier array
+# The neighbor is then marked as visited
 
-  # Processes input from the user on the keyboard.
-  def process_inputs
-    if inputs.mouse.down
-      state.world_lookup = {}
-      x, y = to_coord inputs.mouse.down.point  # gets x, y coordinates for the grid
+# The frontier is blue
+# Visited cells are light brown
+# Walls are camo green
+# Even when walls are visited, they will maintain their wall color
 
-      if state.world.any? { |loc| loc == [x, y] }  # checks if coordinates duplicate
-        state.world = state.world.reject { |loc| loc == [x, y] }  # erases tile space
-      else
-        state.world << [x, y] # If no duplicates, adds to world collection
-      end
-    end
+# The star can be moved by clicking and dragging
+# Walls can be added and removed by clicking and dragging
 
-    # Sets dx to 0 if the player lets go of arrow keys.
-    if inputs.keyboard.key_up.right
-      state.dx = 0
-    elsif inputs.keyboard.key_up.left
-      state.dx = 0
-    end
+class BreadthFirstSearch
+  attr_gtk
 
-    # Sets dx to 3 in whatever direction the player chooses.
-    if inputs.keyboard.key_held.right # if right key is pressed
-      state.dx =  3
-    elsif inputs.keyboard.key_held.left # if left key is pressed
-      state.dx = -3
-    end
+  def initialize(args)
+    # Variables to edit the size and appearance of the grid
+    # Freely customizable to user's liking
+    args.state.grid.width     = 30
+    args.state.grid.height    = 15
+    args.state.grid.cell_size = 40
+
+    # Stores which step of the animation is being rendered
+    # When the user moves the star or messes with the walls,
+    # the breadth first search is recalculated up to this step
+    args.state.anim_steps = 0
+
+    # At some step the animation will end,
+    # and further steps won't change anything (the whole grid will be explored)
+    # This step is roughly the grid's width * height
+    # When anim_steps equals max_steps no more calculations will occur
+    # and the slider will be at the end
+    args.state.max_steps  = args.state.grid.width * args.state.grid.height
+
+    # Whether the animation should play or not
+    # If true, every tick moves anim_steps forward one
+    # Pressing the stepwise animation buttons will pause the animation
+    args.state.play       = true
+
+    # The location of the star and walls of the grid
+    # They can be modified to have a different initial grid
+    # Walls are stored in a hash for quick look up when doing the search
+    args.state.star       = [0, 0]
+    args.state.walls      = {
+      [3, 3] => true,
+      [3, 4] => true,
+      [3, 5] => true,
+      [3, 6] => true,
+      [3, 7] => true,
+      [3, 8] => true,
+      [3, 9] => true,
+      [3, 10] => true,
+      [3, 11] => true,
+      [4, 3] => true,
+      [4, 4] => true,
+      [4, 5] => true,
+      [4, 6] => true,
+      [4, 7] => true,
+      [4, 8] => true,
+      [4, 9] => true,
+      [4, 10] => true,
+      [4, 11] => true,
+
+      [13, 0] => true,
+      [13, 1] => true,
+      [13, 2] => true,
+      [13, 3] => true,
+      [13, 4] => true,
+      [13, 5] => true,
+      [13, 6] => true,
+      [13, 7] => true,
+      [13, 8] => true,
+      [13, 9] => true,
+      [13, 10] => true,
+      [14, 0] => true,
+      [14, 1] => true,
+      [14, 2] => true,
+      [14, 3] => true,
+      [14, 4] => true,
+      [14, 5] => true,
+      [14, 6] => true,
+      [14, 7] => true,
+      [14, 8] => true,
+      [14, 9] => true,
+      [14, 10] => true,
+
+      [21, 8] => true,
+      [21, 9] => true,
+      [21, 10] => true,
+      [21, 11] => true,
+      [21, 12] => true,
+      [21, 13] => true,
+      [21, 14] => true,
+      [22, 8] => true,
+      [22, 9] => true,
+      [22, 10] => true,
+      [22, 11] => true,
+      [22, 12] => true,
+      [22, 13] => true,
+      [22, 14] => true,
+      [23, 8] => true,
+      [23, 9] => true,
+      [24, 8] => true,
+      [24, 9] => true,
+      [25, 8] => true,
+      [25, 9] => true,
+    }
 
-    #Sets dy to 5 to make the player ~fly~ when they press the space bar
-    if inputs.keyboard.key_held.space
-      state.dy = 5
+    # Variables that are used by the breadth first search
+    # Storing cells that the search has visited, prevents unnecessary steps
+    # Expanding the frontier of the search in order makes the search expand
+    # from the center outward
+    args.state.visited    = {}
+    args.state.frontier   = []
+
+
+    # What the user is currently editing on the grid
+    # Possible values are: :none, :slider, :star, :remove_wall, :add_wall
+
+    # We store this value, because we want to remember the value even when
+    # the user's cursor is no longer over what they're interacting with, but
+    # they are still clicking down on the mouse.
+    args.state.click_and_drag = :none
+
+    # Store the rects of the buttons that control the animation
+    # They are here for user customization
+    # Editing these might require recentering the text inside them
+    # Those values can be found in the render_button methods
+    args.state.buttons.left   = [450, 600, 50, 50]
+    args.state.buttons.center = [500, 600, 200, 50]
+    args.state.buttons.right  = [700, 600, 50, 50]
+
+    # The variables below are related to the slider
+    # They allow the user to customize them
+    # They also give a central location for the render and input methods to get
+    # information from
+    # x & y are the coordinates of the leftmost part of the slider line
+    args.state.slider.x = 400
+    args.state.slider.y = 675
+    # This is the width of the line
+    args.state.slider.w = 360
+    # This is the offset for the circle
+    # Allows the center of the circle to be on the line,
+    # as opposed to the upper right corner
+    args.state.slider.offset = 20
+    # This is the spacing between each of the notches on the slider
+    # Notches are places where the circle can rest on the slider line
+    # There needs to be a notch for each step before the maximum number of steps
+    args.state.slider.spacing = args.state.slider.w.to_f / args.state.max_steps.to_f
+  end
+
+  # This method is called every frame/tick
+  # Every tick, the current state of the search is rendered on the screen,
+  # User input is processed, and
+  # The next step in the search is calculated
+  def tick
+    render
+    input
+    # If animation is playing, and max steps have not been reached
+    # Move the search a step forward
+    if state.play && state.anim_steps < state.max_steps
+      # Variable that tells the program what step to recalculate up to
+      state.anim_steps += 1
+      calc
     end
   end
 
-  def to_coord point
+  # Draws everything onto the screen
+  def render
+    render_buttons
+    render_slider
 
-    # Integer divides (idiv) point.x to turn into grid
-    # Then, you can just multiply each integer by state.tile_size later so the grid coordinates.
-    [point.x.idiv(state.tile_size), point.y.idiv(state.tile_size)]
+    render_background
+    render_visited
+    render_frontier
+    render_walls
+    render_star
+  end
+
+  # The methods below subdivide the task of drawing everything to the screen
+
+  # Draws the buttons that control the animation step and state
+  def render_buttons
+    render_left_button
+    render_center_button
+    render_right_button
+  end
+
+  # Draws the button which steps the search backward
+  # Shows the user where to click to move the search backward
+  def render_left_button
+    # Draws the gray button, and a black border
+    # The border separates the buttons visually
+    outputs.solids  << [buttons.left, gray]
+    outputs.borders << [buttons.left, black]
+
+    # Renders an explanatory label in the center of the button
+    # Explains to the user what the button does
+    # If the button size is changed, the label might need to be edited as well
+    # to keep the label in the center of the button
+    label_x = buttons.left.x + 20
+    label_y = buttons.left.y + 35
+    outputs.labels  << [label_x, label_y, "<"]
+  end
+
+  def render_center_button
+    # Draws the gray button, and a black border
+    # The border separates the buttons visually
+    outputs.solids  << [buttons.center, gray]
+    outputs.borders << [buttons.center, black]
+
+    # Renders an explanatory label in the center of the button
+    # Explains to the user what the button does
+    # If the button size is changed, the label might need to be edited as well
+    # to keep the label in the center of the button
+    label_x    = buttons.center.x + 37
+    label_y    = buttons.center.y + 35
+    label_text = state.play ? "Pause Animation" : "Play Animation"
+    outputs.labels << [label_x, label_y, label_text]
+  end
+
+  def render_right_button
+    # Draws the gray button, and a black border
+    # The border separates the buttons visually
+    outputs.solids  << [buttons.right, gray]
+    outputs.borders << [buttons.right, black]
+
+    # Renders an explanatory label in the center of the button
+    # Explains to the user what the button does
+    label_x = buttons.right.x + 20
+    label_y = buttons.right.y + 35
+    outputs.labels  << [label_x, label_y, ">"]
+  end
+
+  # Draws the slider so the user can move it and see the progress of the search
+  def render_slider
+    # Using primitives hides the line under the white circle of the slider
+    # Draws the line
+    outputs.primitives << [slider.x, slider.y, slider.x + slider.w, slider.y].line
+    # The circle needs to be offset so that the center of the circle
+    # overlaps the line instead of the upper right corner of the circle
+    # The circle's x value is also moved based on the current seach step
+    circle_x = (slider.x - slider.offset) + (state.anim_steps * slider.spacing)
+    circle_y = (slider.y - slider.offset)
+    circle_rect = [circle_x, circle_y, 37, 37]
+    outputs.primitives << [circle_rect, 'circle-white.png'].sprite
+  end
+
+  # Draws what the grid looks like with nothing on it
+  def render_background
+    render_unvisited
+    render_grid_lines
   end
 
-  # Represents the tolerance for a collision between the player's rect and another rect.
-  def collision_tollerance
-    0.0
+  # Draws a rectangle the size of the entire grid to represent unvisited cells
+  def render_unvisited
+    outputs.solids << [scale_up([0, 0, grid.width, grid.height]), unvisited_color]
   end
-end
 
-$platformer_physics = PoorManPlatformerPhysics.new
-
-def tick args
-  $platformer_physics.grid    = args.grid
-  $platformer_physics.inputs  = args.inputs
-  $platformer_physics.state    = args.state
-  $platformer_physics.outputs = args.outputs
-  $platformer_physics.tick
-  tick_instructions args, "Sample app shows platformer collisions. CLICK to place box. ARROW keys to move around. SPACE to jump."
-end
+  # Draws grid lines to show the division of the grid into cells
+  def render_grid_lines
+    for x in 0..grid.width
+      outputs.lines << vertical_line(x)
+    end
 
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
+    for y in 0..grid.height
+      outputs.lines << horizontal_line(y)
+    end
   end
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
-end
-
-

-Physics And Collisions - Box Collision 2 - main.rb
-# ./samples/04_physics_and_collisions/05_box_collision_2/app/main.rb
-=begin
- APIs listing that haven't been encountered in previous sample apps:
-
- - times: Performs an action a specific number of times.
-   For example, if we said
-   5.times puts "Hello DragonRuby",
-   then we'd see the words "Hello DragonRuby" printed on the console 5 times.
-
- - split: Divides a string into substrings based on a delimiter.
-   For example, if we had a command
-   "DragonRuby is awesome".split(" ")
-   then the result would be
-   ["DragonRuby", "is", "awesome"] because the words are separated by a space delimiter.
-
- - join: Opposite of split; converts each element of array to a string separated by delimiter.
-   For example, if we had a command
-   ["DragonRuby","is","awesome"].join(" ")
-   then the result would be
-   "DragonRuby is awesome".
-
- Reminders:
+  # Easy way to draw vertical lines given an index
+  def vertical_line column
+    scale_up([column, 0, column, grid.height])
+  end
 
- - to_s: Returns a string representation of an object.
-   For example, if we had
-   500.to_s
-   the string "500" would be returned.
-   Similar to to_i, which returns an integer representation of an object.
+  # Easy way to draw horizontal lines given an index
+  def horizontal_line row
+    scale_up([0, row, grid.width, row])
+  end
 
- - elapsed_time: How many frames have passed since the click event.
+  # Draws the area that is going to be searched from
+  # The frontier is the most outward parts of the search
+  def render_frontier
+    outputs.solids << state.frontier.map do |cell|
+      [scale_up([cell.x, cell.y]), frontier_color]
+    end
+  end
 
- - args.outputs.labels: An array. Values in the array generate labels on the screen.
-   The parameters are: [X, Y, TEXT, SIZE, ALIGN, RED, GREEN, BLUE, ALPHA, FONT STYLE]
-   For more information about labels, go to mygame/documentation/02-labels.md.
+  # Draws the walls
+  def render_walls
+    outputs.solids << state.walls.map do |wall|
+      [scale_up([wall.x, wall.y]), wall_color]
+    end
+  end
 
- - inputs.mouse.down: Determines whether or not the mouse is being pressed down.
-   The position of the mouse when it is pressed down can be found using inputs.mouse.down.point.(x|y).
+  # Renders cells that have been searched in the appropriate color
+  def render_visited
+    outputs.solids << state.visited.map do |cell|
+      [scale_up([cell.x, cell.y]), visited_color]
+    end
+  end
 
- - first: Returns the first element of the array.
+  # Renders the star
+  def render_star
+    outputs.sprites << [scale_up(state.star), 'star.png']
+  end
 
- - num1.idiv(num2): Divides two numbers and returns an integer.
+  # In code, the cells are represented as 1x1 rectangles
+  # When drawn, the cells are larger than 1x1 rectangles
+  # This method is used to scale up cells, and lines
+  # Objects are scaled up according to the grid.cell_size variable
+  # This allows for easy customization of the visual scale of the grid
+  def scale_up(cell)
+    # Prevents the original value of cell from being edited
+    cell = cell.clone
 
- - find_all: Finds all values that satisfy specific requirements.
+    # If cell is just an x and y coordinate
+    if cell.size == 2
+      # Add a width and height of 1
+      cell << 1
+      cell << 1
+    end
 
- - ARRAY#intersect_rect?: Returns true or false depending on if two rectangles intersect.
+    # Scale all the values up
+    cell.map! { |value| value * grid.cell_size }
 
- - reject: Removes elements from a collection if they meet certain requirements.
+    # Returns the scaled up cell
+    cell
+  end
 
- - String interpolation: Uses #{} syntax; everything between the #{ and the } is evaluated
-   as Ruby code, and the placeholder is replaced with its corresponding value or result.
+  # This method processes user input every tick
+  # This method allows the user to use the buttons, slider, and edit the grid
+  # There are 2 types of input:
+  #   Button Input
+  #   Click and Drag Input
+  #
+  #   Button Input is used for the backward step and forward step buttons
+  #   Input is detected by mouse up within the bounds of the rect
+  #
+  #   Click and Drag Input is used for moving the star, adding walls,
+  #   removing walls, and the slider
+  #
+  #   When the mouse is down on the star, the click_and_drag variable is set to :star
+  #   While click_and_drag equals :star, the cursor's position is used to calculate the
+  #   appropriate drag behavior
+  #
+  #   When the mouse goes up click_and_drag is set to :none
+  #
+  #   A variable has to be used because the star has to continue being edited even
+  #   when the cursor is no longer over the star
+  #
+  #   Similar things occur for the other Click and Drag inputs
+  def input
+    # Checks whether any of the buttons are being clicked
+    input_buttons
 
-=end
+    # The detection and processing of click and drag inputs are separate
+    # The program has to remember that the user is dragging an object
+    # even when the mouse is no longer over that object
+    detect_click_and_drag
+    process_click_and_drag
+  end
 
-MAP_FILE_PATH = 'app/map.txt' # the map.txt file in the app folder contains exported map
+  # Detects and Process input for each button
+  def input_buttons
+    input_left_button
+    input_center_button
+    input_next_step_button
+  end
 
-class MetroidvaniaStarter
-  attr_accessor :grid, :inputs, :state, :outputs, :gtk
+  # Checks if the previous step button is clicked
+  # If it is, it pauses the animation and moves the search one step backward
+  def input_left_button
+    if left_button_clicked?
+      state.play = false
+      state.anim_steps -= 1
+      recalculate
+    end
+  end
 
-  # Calls methods needed to run the game properly.
-  def tick
-    defaults
-    render
-    calc
-    process_inputs
+  # Controls the play/pause button
+  # Inverses whether the animation is playing or not when clicked
+  def input_center_button
+    if center_button_clicked? or inputs.keyboard.key_down.space
+      state.play = !state.play
+    end
   end
 
-  # Sets all the default variables.
-  # '||' states that initialization occurs only in the first frame.
-  def defaults
-    state.tile_size                = 64
-    state.gravity                  = -0.2
-    state.player_width             = 60
-    state.player_height            = 64
-    state.collision_tolerance      = 0.0
-    state.previous_tile_size     ||= state.tile_size
-    state.x                      ||= 0
-    state.y                      ||= 800
-    state.dy                     ||= 0
-    state.dx                     ||= 0
-    attempt_load_world_from_file
-    state.world_lookup           ||= { }
-    state.world_collision_rects  ||= []
-    state.mode                   ||= :creating # alternates between :creating and :selecting for sprite selection
-    state.select_menu            ||= [0, 720, 1280, 720]
-    #=======================================IMPORTANT=======================================#
-    # When adding sprites, please label them "image1.png", "image2.png", image3".png", etc.
-    # Once you have done that, adjust "state.sprite_quantity" to how many sprites you have.
-    #=======================================================================================#
-    state.sprite_quantity        ||= 20 # IMPORTANT TO ALTER IF SPRITES ADDED IF YOU ADD MORE SPRITES
-    state.sprite_coords          ||= []
-    state.banner_coords          ||= [640, 680 + 720]
-    state.sprite_selected        ||= 1
-    state.map_saved_at           ||= 0
+  # Checks if the next step button is clicked
+  # If it is, it pauses the animation and moves the search one step forward
+  def input_next_step_button
+    if right_button_clicked?
+      state.play = false
+      state.anim_steps += 1
+      calc
+    end
+  end
 
-    # Sets all the cordinate values for the sprite selection screen into a grid
-    # Displayed when 's' is pressed by player to access sprites
-    if state.sprite_coords == [] # if sprite_coords is an empty array
-      count = 1
-      temp_x = 165 # sets a starting x and y position for display
-      temp_y = 500 + 720
-      state.sprite_quantity.times do # for the number of sprites you have
-        state.sprite_coords += [[temp_x, temp_y, count]] # add element to sprite_coords array
-        temp_x += 100 # increment temp_x
-        count += 1 # increment count
-        if temp_x > 1280 - (165 + 50) # if exceeding specific horizontal width on screen
-          temp_x = 165 # a new row of sprites starts
-          temp_y -= 75 # new row of sprites starts 75 units lower than the previous row
-        end
+  # Determines what the user is editing and stores the value
+  # Storing the value allows the user to continue the same edit as long as the
+  # mouse left click is held
+  def detect_click_and_drag
+    if inputs.mouse.up
+      state.click_and_drag = :none
+    elsif star_clicked?
+      state.click_and_drag = :star
+    elsif wall_clicked?
+      state.click_and_drag = :remove_wall
+    elsif grid_clicked?
+      state.click_and_drag = :add_wall
+    elsif slider_clicked?
+      state.click_and_drag = :slider
+    end
+  end
+
+  # Processes click and drag based on what the user is currently dragging
+  def process_click_and_drag
+    if state.click_and_drag == :star
+      input_star
+    elsif state.click_and_drag == :remove_wall
+      input_remove_wall
+    elsif state.click_and_drag == :add_wall
+      input_add_wall
+    elsif state.click_and_drag == :slider
+      input_slider
+    end
+  end
+
+  # Moves the star to the grid closest to the mouse
+  # Only recalculates the search if the star changes position
+  # Called whenever the user is editing the star (puts mouse down on star)
+  def input_star
+    old_star = state.star.clone
+    state.star = cell_closest_to_mouse
+    unless old_star == state.star
+      recalculate
+    end
+  end
+
+  # Removes walls that are under the cursor
+  def input_remove_wall
+    # The mouse needs to be inside the grid, because we only want to remove walls
+    # the cursor is directly over
+    # Recalculations should only occur when a wall is actually deleted
+    if mouse_inside_grid?
+      if state.walls.has_key?(cell_closest_to_mouse)
+        state.walls.delete(cell_closest_to_mouse)
+        recalculate
+      end
+    end
+  end
+
+  # Adds walls at cells under the cursor
+  def input_add_wall
+    if mouse_inside_grid?
+      unless state.walls.has_key?(cell_closest_to_mouse)
+        state.walls[cell_closest_to_mouse] = true
+        recalculate
       end
     end
   end
 
-  # Places sprites
-  def render
+  # This method is called when the user is editing the slider
+  # It pauses the animation and moves the white circle to the closest integer point
+  # on the slider
+  # Changes the step of the search to be animated
+  def input_slider
+    state.play = false
+    mouse_x = inputs.mouse.point.x
 
-    # Sets the x, y, width, height, and image path for each sprite in the world collection.
-    outputs.sprites << state.world.map do |x, y, sprite|
-      [x * state.tile_size, # multiply by size so grid coordinates; pixel value of location
-       y * state.tile_size,
-       state.tile_size,
-       state.tile_size,
-       'sprites/image' + sprite.to_s + '.png'] # uses concatenation to create unique image path
-    end
+    # Bounds the mouse_x to the closest x value on the slider line
+    mouse_x = slider.x if mouse_x < slider.x
+    mouse_x = slider.x + slider.w if mouse_x > slider.x + slider.w
 
-    # Outputs sprite for the player by setting x, y, width, height, and image path
-    outputs.sprites << [state.x,
-                        state.y,
-                        state.player_width,
-                        state.player_height,'sprites/player.png']
+    # Sets the current search step to the one represented by the mouse x value
+    # The slider's circle moves due to the render_slider method using anim_steps
+    state.anim_steps = ((mouse_x - slider.x) / slider.spacing).to_i
 
-    # Outputs labels as primitives in top right of the screen
-    outputs.primitives << [920, 700, 'Press \'s\' to access sprites.', 1, 0].label
-    outputs.primitives << [920, 675, 'Click existing sprite to delete.', 1, 0].label
+    recalculate
+  end
 
-    outputs.primitives << [920, 640, '<- and -> to move.', 1, 0].label
-    outputs.primitives << [920, 615, 'Press and hold space to jump.', 1, 0].label
+  # Whenever the user edits the grid,
+  # The search has to be recalculated upto the current step
+  # with the current grid as the initial state of the grid
+  def recalculate
+    # Resets the search
+    state.frontier = []
+    state.visited = {}
 
-    outputs.primitives << [920, 580, 'Press \'e\' to export current map.', 1, 0].label
+    # Moves the animation forward one step at a time
+    state.anim_steps.times { calc }
+  end
 
-    # if the map is saved and less than 120 frames have passed, the label is displayed
-    if state.map_saved_at > 0 && state.map_saved_at.elapsed_time < 120
-      outputs.primitives << [920, 555, 'Map has been exported!', 1, 0, 50, 100, 50].label
-    end
 
-    # If player hits 's', following appears
-    if state.mode == :selecting
-      # White background for sprite selection
-      outputs.primitives << [state.select_menu, 255, 255, 255].solid
+  # This method moves the search forward one step
+  # When the animation is playing it is called every tick
+  # And called whenever the current step of the animation needs to be recalculated
 
-      # Select tile label at the top of the screen
-      outputs.primitives << [state.banner_coords.x, state.banner_coords.y, "Select Sprite (sprites located in \"sprites\" folder)", 10, 1, 0, 0, 0, 255].label
+  # Moves the search forward one step
+  # Parameter called_from_tick is true if it is called from the tick method
+  # It is false when the search is being recalculated after user editing the grid
+  def calc
 
-      # Places sprites in locations calculated in the defaults function
-      outputs.primitives << state.sprite_coords.map do |x, y, order|
-        [x, y, 50, 50, 'sprites/image' + order.to_s + ".png"].sprite
+    # The setup to the search
+    # Runs once when the there is no frontier or visited cells
+    if state.frontier.empty? && state.visited.empty?
+      state.frontier << state.star
+      state.visited[state.star] = true
+    end
+
+    # A step in the search
+    unless state.frontier.empty?
+      # Takes the next frontier cell
+      new_frontier = state.frontier.shift
+      # For each of its neighbors
+      adjacent_neighbors(new_frontier).each do |neighbor|
+        # That have not been visited and are not walls
+        unless state.visited.has_key?(neighbor) || state.walls.has_key?(neighbor)
+          # Add them to the frontier and mark them as visited
+          state.frontier << neighbor
+          state.visited[neighbor] = true
+        end
       end
     end
+  end
 
-    # Creates sprite following mouse to help indicate which sprite you have selected
-    # 10 is subtracted from the mouse's x position so that the sprite is not covered by the mouse icon
-    outputs.primitives << [inputs.mouse.position.x - 10, inputs.mouse.position.y,
-                           10, 10, 'sprites/image' + state.sprite_selected.to_s + ".png"].sprite
+
+  # Returns a list of adjacent cells
+  # Used to determine what the next cells to be added to the frontier are
+  def adjacent_neighbors(cell)
+    neighbors = []
+
+    neighbors << [cell.x, cell.y + 1] unless cell.y == grid.height - 1
+    neighbors << [cell.x + 1, cell.y] unless cell.x == grid.width - 1
+    neighbors << [cell.x, cell.y - 1] unless cell.y == 0
+    neighbors << [cell.x - 1, cell.y] unless cell.x == 0
+
+    neighbors
   end
 
-  # Calls methods that perform calculations
-  def calc
-    calc_in_game
-    calc_sprite_selection
+  # When the user grabs the star and puts their cursor to the far right
+  # and moves up and down, the star is supposed to move along the grid as well
+  # Finding the cell closest to the mouse helps with this
+  def cell_closest_to_mouse
+    # Closest cell to the mouse
+    x = (inputs.mouse.point.x / grid.cell_size).to_i
+    y = (inputs.mouse.point.y / grid.cell_size).to_i
+    # Bound x and y to the grid
+    x = grid.width - 1 if x > grid.width - 1
+    y = grid.height - 1 if y > grid.height - 1
+    # Return closest cell
+    [x, y]
   end
 
-  # Calls methods that perform calculations (if in creating mode)
-  def calc_in_game
-    return unless state.mode == :creating
-    calc_world_lookup
-    calc_player
+  # These methods detect when the buttons are clicked
+  def left_button_clicked?
+    inputs.mouse.up && inputs.mouse.point.inside_rect?(buttons.left)
   end
 
-  def calc_world_lookup
-    # If the tile size isn't equal to the previous tile size,
-    # the previous tile size is set to the tile size,
-    # and world_lookup hash is set to empty.
-    if state.tile_size != state.previous_tile_size
-      state.previous_tile_size = state.tile_size
-      state.world_lookup = {}
+  def center_button_clicked?
+    inputs.mouse.up && inputs.mouse.point.inside_rect?(buttons.center)
+  end
+
+  def right_button_clicked?
+    inputs.mouse.up && inputs.mouse.point.inside_rect?(buttons.right)
+  end
+
+  # Signal that the user is going to be moving the slider
+  # Is the mouse down on the circle of the slider?
+  def slider_clicked?
+    circle_x = (slider.x - slider.offset) + (state.anim_steps * slider.spacing)
+    circle_y = (slider.y - slider.offset)
+    circle_rect = [circle_x, circle_y, 37, 37]
+    inputs.mouse.down && inputs.mouse.point.inside_rect?(circle_rect)
+  end
+
+  # Signal that the user is going to be moving the star
+  def star_clicked?
+    inputs.mouse.down && inputs.mouse.point.inside_rect?(scale_up(state.star))
+  end
+
+  # Signal that the user is going to be removing walls
+  def wall_clicked?
+    inputs.mouse.down && mouse_inside_a_wall?
+  end
+
+  # Signal that the user is going to be adding walls
+  def grid_clicked?
+    inputs.mouse.down && mouse_inside_grid?
+  end
+
+  # Returns whether the mouse is inside of a wall
+  # Part of the condition that checks whether the user is removing a wall
+  def mouse_inside_a_wall?
+    state.walls.each_key do | wall |
+      return true if inputs.mouse.point.inside_rect?(scale_up([wall.x, wall.y]))
     end
 
-    # return if world_lookup is not empty or if world is empty
-    return if state.world_lookup.keys.length > 0
-    return unless state.world.length > 0
+    false
+  end
 
-    # Searches through the world and finds the coordinates that exist
-    state.world_lookup = {}
-    state.world.each { |x, y| state.world_lookup[[x, y]] = true }
+  # Returns whether the mouse is inside of a grid
+  # Part of the condition that checks whether the user is adding a wall
+  def mouse_inside_grid?
+    inputs.mouse.point.inside_rect?(scale_up([0, 0, grid.width, grid.height]))
+  end
 
-    # Assigns collision rects for every sprite drawn
-    state.world_collision_rects =
-      state.world_lookup
-           .keys
-           .map do |coord_x, coord_y|
-             s = state.tile_size
-             # Multiplying by s (the size of a tile) ensures that the rect is
-             # placed exactly where you want it to be placed (causes grid to coordinate)
-             # How many pixels horizontally across and vertically up and down
-             x = s * coord_x
-             y = s * coord_y
-             {
-               args:       [coord_x, coord_y],
-               left_right: [x,     y + 4, s,     s - 6], # hash keys and values
-               top:        [x + 4, y + 6, s - 8, s - 6],
-               bottom:     [x + 1, y - 1, s - 2, s - 8],
-             }
-           end
+
+  # These methods provide handy aliases to colors
+
+  # Light brown
+  def unvisited_color
+    [221, 212, 213]
   end
 
-  # Calculates movement of player and calls methods that perform collision calculations
-  def calc_player
-    state.dy += state.gravity  # what goes up must come down because of gravity
-    calc_box_collision
-    calc_edge_collision
-    state.y  += state.dy       # Since velocity is the change in position, the change in y increases by dy
-    state.x  += state.dx       # Ditto line above but dx and x
-    state.dx *= 0.8            # Scales dx down
+  # Black
+  def grid_line_color
+    [255, 255, 255]
   end
 
-  # Calls methods that determine whether the player collides with any world_collision_rects.
-  def calc_box_collision
-    return unless state.world_lookup.keys.length > 0 # return unless hash has atleast 1 key
-    collision_floor
-    collision_left
-    collision_right
-    collision_ceiling
+  # Dark Brown
+  def visited_color
+    [204, 191, 179]
   end
 
-  # Finds collisions between the bottom of the player's rect and the top of a world_collision_rect.
-  def collision_floor
-    return unless state.dy <= 0 # return unless player is going down or is as far down as possible
-    player_rect = [state.x, next_y, state.tile_size, state.tile_size] # definition of player
+  # Blue
+  def frontier_color
+    [103, 136, 204]
+  end
 
-    # Runs through all the sprites on the field and finds all intersections between player's
-    # bottom and the top of a rect.
-    floor_collisions = state.world_collision_rects
-                         .find_all { |r| r[:top].intersect_rect?(player_rect, state.collision_tolerance) }
-                         .first
+  # Camo Green
+  def wall_color
+    [134, 134, 120]
+  end
 
-    return unless floor_collisions # performs following changes if a collision has occurred
-    state.y = floor_collisions[:top].top # y of player is set to the y of the colliding rect's top
-    state.dy = 0 # no change in y because the player's path is blocked
+  # Button Background
+  def gray
+    [190, 190, 190]
   end
 
-  # Finds collisions between the player's left side and the right side of a world_collision_rect.
-  def collision_left
-    return unless state.dx < 0 # return unless player is moving left
-    player_rect = [next_x, state.y, state.tile_size, state.tile_size]
+  # Button Outline
+  def black
+    [0, 0, 0]
+  end
 
-    # Runs through all the sprites on the field and finds all intersections between the player's left side
-    # and the right side of a rect.
-    left_side_collisions = state.world_collision_rects
-                             .find_all { |r| r[:left_right].intersect_rect?(player_rect, state.collision_tolerance) }
-                             .first
+  # These methods make the code more concise
+  def grid
+    state.grid
+  end
 
-    return unless left_side_collisions # return unless collision occurred
-    state.x = left_side_collisions[:left_right].right # sets player's x to the x of the colliding rect's right side
-    state.dx = 0 # no change in x because the player's path is blocked
+  def buttons
+    state.buttons
   end
 
-  # Finds collisions between the right side of the player and the left side of a world_collision_rect.
-  def collision_right
-    return unless state.dx > 0 # return unless player is moving right
-    player_rect = [next_x, state.y, state.tile_size, state.tile_size]
+  def slider
+    state.slider
+  end
+end
 
-    # Runs through all the sprites on the field and finds all intersections between the  player's
-    # right side and the left side of a rect.
-    right_side_collisions = state.world_collision_rects
-                              .find_all { |r| r[:left_right].intersect_rect?(player_rect, state.collision_tolerance) }
-                              .first
+# Method that is called by DragonRuby periodically
+# Used for updating animations and calculations
+def tick args
 
-    return unless right_side_collisions # return unless collision occurred
-    state.x = right_side_collisions[:left_right].left - state.tile_size # player's x is set to the x of colliding rect's left side (minus tile size since x is the player's bottom left corner)
-    state.dx = 0 # no change in x because the player's path is blocked
+  # Pressing r will reset the application
+  if args.inputs.keyboard.key_down.r
+    args.gtk.reset
+    reset
+    return
   end
 
-  # Finds collisions between the top of the player's rect and the bottom of a world_collision_rect.
-  def collision_ceiling
-    return unless state.dy > 0 # return unless player is moving up
-    player_rect = [state.x, next_y, state.player_width, state.player_height]
+  # Every tick, new args are passed, and the Breadth First Search tick is called
+  $breadth_first_search ||= BreadthFirstSearch.new(args)
+  $breadth_first_search.args = args
+  $breadth_first_search.tick
+end
 
-    # Runs through all the sprites on the field and finds all intersections between the player's top
-    # and the bottom of a rect.
-    ceil_collisions = state.world_collision_rects
-                        .find_all { |r| r[:bottom].intersect_rect?(player_rect, state.collision_tolerance) }
-                        .first
 
-    return unless ceil_collisions # return unless collision occurred
-    state.y = ceil_collisions[:bottom].y - state.tile_size # player's y is set to the y of the colliding rect's bottom (minus tile size)
-    state.dy = 0 # no change in y because the player's path is blocked
+def reset
+  $breadth_first_search = nil
+end
+
+
+Path Finding Algorithms - Detailed Breadth First Search - main.rb
+# ./samples/13_path_finding_algorithms/02_detailed_breadth_first_search/app/main.rb
+# A visual demonstration of a breadth first search
+# Inspired by https://www.redblobgames.com/pathfinding/a-star/introduction.html
+
+# An animation that can respond to user input in real time
+
+# A breadth first search expands in all directions one step at a time
+# The frontier is a queue of cells to be expanded from
+# The visited hash allows quick lookups of cells that have been expanded from
+# The walls hash allows quick lookup of whether a cell is a wall
+
+# The breadth first search starts by adding the red star to the frontier array
+# and marking it as visited
+# Each step a cell is removed from the front of the frontier array (queue)
+# Unless the neighbor is a wall or visited, it is added to the frontier array
+# The neighbor is then marked as visited
+
+# The frontier is blue
+# Visited cells are light brown
+# Walls are camo green
+# Even when walls are visited, they will maintain their wall color
+
+# This search numbers the order in which new cells are explored
+# The next cell from where the search will continue is highlighted yellow
+# And the cells that will be considered for expansion are in semi-transparent green
+
+# The star can be moved by clicking and dragging
+# Walls can be added and removed by clicking and dragging
+
+class DetailedBreadthFirstSearch
+  attr_gtk
+
+  def initialize(args)
+    # Variables to edit the size and appearance of the grid
+    # Freely customizable to user's liking
+    args.state.grid.width     = 9
+    args.state.grid.height    = 4
+    args.state.grid.cell_size = 90
+
+    # Stores which step of the animation is being rendered
+    # When the user moves the star or messes with the walls,
+    # the breadth first search is recalculated up to this step
+    args.state.anim_steps = 0
+
+    # At some step the animation will end,
+    # and further steps won't change anything (the whole grid will be explored)
+    # This step is roughly the grid's width * height
+    # When anim_steps equals max_steps no more calculations will occur
+    # and the slider will be at the end
+    args.state.max_steps  = args.state.grid.width * args.state.grid.height
+
+    # The location of the star and walls of the grid
+    # They can be modified to have a different initial grid
+    # Walls are stored in a hash for quick look up when doing the search
+    args.state.star       = [3, 2]
+    args.state.walls      = {}
+
+    # Variables that are used by the breadth first search
+    # Storing cells that the search has visited, prevents unnecessary steps
+    # Expanding the frontier of the search in order makes the search expand
+    # from the center outward
+    args.state.visited    = {}
+    args.state.frontier   = []
+    args.state.cell_numbers = []
+
+
+
+    # What the user is currently editing on the grid
+    # Possible values are: :none, :slider, :star, :remove_wall, :add_wall
+
+    # We store this value, because we want to remember the value even when
+    # the user's cursor is no longer over what they're interacting with, but
+    # they are still clicking down on the mouse.
+    args.state.click_and_drag = :none
+
+    # The x, y, w, h values for the buttons
+    # Allow easy movement of the buttons location
+    # A centralized location to get values to detect input and draw the buttons
+    # Editing these values might mean needing to edit the label offsets
+    # which can be found in the appropriate render button methods
+    args.state.buttons.left  = [450, 600, 160, 50]
+    args.state.buttons.right = [610, 600, 160, 50]
+
+    # The variables below are related to the slider
+    # They allow the user to customize them
+    # They also give a central location for the render and input methods to get
+    # information from
+    # x & y are the coordinates of the leftmost part of the slider line
+    args.state.slider.x = 400
+    args.state.slider.y = 675
+    # This is the width of the line
+    args.state.slider.w = 360
+    # This is the offset for the circle
+    # Allows the center of the circle to be on the line,
+    # as opposed to the upper right corner
+    args.state.slider.offset = 20
+    # This is the spacing between each of the notches on the slider
+    # Notches are places where the circle can rest on the slider line
+    # There needs to be a notch for each step before the maximum number of steps
+    args.state.slider.spacing = args.state.slider.w.to_f / args.state.max_steps.to_f
+  end
+
+  # This method is called every frame/tick
+  # Every tick, the current state of the search is rendered on the screen,
+  # User input is processed, and
+  def tick
+    render
+    input
   end
 
-  # Makes sure the player remains within the screen's dimensions.
-  def calc_edge_collision
-    # Ensures that player doesn't fall below the map
-    if next_y < 0 && state.dy < 0 # if player is moving down and is about to fall (next_y) below the map's scope
-      state.y = 0 # 0 is the lowest the player can be while staying on the screen
-      state.dy = 0
-    # Ensures player doesn't go insanely high
-    elsif next_y > 720 - state.tile_size && state.dy > 0 # if player is moving up, about to exceed map's scope
-      state.y = 720 - state.tile_size # if we don't subtract tile_size, we won't be able to see the player on the screen
-      state.dy = 0
+  # This method is called from tick and renders everything every tick
+  def render
+    render_buttons
+    render_slider
+
+    render_background
+    render_visited
+    render_frontier
+    render_walls
+    render_star
+
+    render_highlights
+    render_cell_numbers
+  end
+
+  # The methods below subdivide the task of drawing everything to the screen
+
+  # Draws the buttons that move the search backward or forward
+  # These buttons are rendered so the user knows where to click to move the search
+  def render_buttons
+    render_left_button
+    render_right_button
+  end
+
+  # Renders the button which steps the search backward
+  # Shows the user where to click to move the search backward
+  def render_left_button
+    # Draws the gray button, and a black border
+    # The border separates the buttons visually
+    outputs.solids  << [buttons.left, gray]
+    outputs.borders << [buttons.left, black]
+
+    # Renders an explanatory label in the center of the button
+    # Explains to the user what the button does
+    label_x = buttons.left.x + 05
+    label_y = buttons.left.y + 35
+    outputs.labels  << [label_x, label_y, "< Step backward"]
+  end
+
+  # Renders the button which steps the search forward
+  # Shows the user where to click to move the search forward
+  def render_right_button
+    # Draws the gray button, and a black border
+    # The border separates the buttons visually
+    outputs.solids  << [buttons.right, gray]
+    outputs.borders << [buttons.right, black]
+
+    # Renders an explanatory label in the center of the button
+    # Explains to the user what the button does
+    label_x = buttons.right.x + 10
+    label_y = buttons.right.y + 35
+    outputs.labels  << [label_x, label_y, "Step forward >"]
+  end
+
+  # Draws the slider so the user can move it and see the progress of the search
+  def render_slider
+    # Using primitives hides the line under the white circle of the slider
+    # Draws the line
+    outputs.primitives << [slider.x, slider.y, slider.x + slider.w, slider.y].line
+    # The circle needs to be offset so that the center of the circle
+    # overlaps the line instead of the upper right corner of the circle
+    # The circle's x value is also moved based on the current seach step
+    circle_x = (slider.x - slider.offset) + (state.anim_steps * slider.spacing)
+    circle_y = (slider.y - slider.offset)
+    circle_rect = [circle_x, circle_y, 37, 37]
+    outputs.primitives << [circle_rect, 'circle-white.png'].sprite
+  end
+
+  # Draws what the grid looks like with nothing on it
+  # Which is a bunch of unvisited cells
+  # Drawn first so other things can draw on top of it
+  def render_background
+    render_unvisited
+
+    # The grid lines make the cells appear separate
+    render_grid_lines
+  end
+
+  # Draws a rectangle the size of the entire grid to represent unvisited cells
+  # Unvisited cells are the default cell
+  def render_unvisited
+    background = [0, 0, grid.width, grid.height]
+    outputs.solids << [scale_up(background), unvisited_color]
+  end
+
+  # Draws grid lines to show the division of the grid into cells
+  def render_grid_lines
+    for x in 0..grid.width
+      outputs.lines << [scale_up(vertical_line(x)), grid_line_color]
     end
 
-    # Ensures that player remains in the horizontal range its supposed to
-    if state.x >= 1280 - state.tile_size && state.dx > 0 # if the player is moving too far right
-      state.x = 1280 - state.tile_size # farthest right the player can be while remaining in the screen's scope
-      state.dx = 0
-    elsif state.x <= 0 && state.dx < 0 # if the player is moving too far left
-      state.x = 0 # farthest left the player can be while remaining in the screen's scope
-      state.dx = 0
+    for y in 0..grid.height
+      outputs.lines << [scale_up(horizontal_line(y)), grid_line_color]
+    end
+  end
+
+  # Easy way to get a vertical line given an index
+  def vertical_line column
+    [column, 0, column, grid.height]
+  end
+
+  # Easy way to get a horizontal line given an index
+  def horizontal_line row
+    [0, row, grid.width, row]
+  end
+
+  # Draws the area that is going to be searched from
+  # The frontier is the most outward parts of the search
+  def render_frontier
+    state.frontier.each do |cell|
+      outputs.solids << [scale_up(cell), frontier_color]
+    end
+  end
+
+  # Draws the walls
+  def render_walls
+    state.walls.each_key do |wall|
+      outputs.solids << [scale_up(wall), wall_color]
+    end
+  end
+
+  # Renders cells that have been searched in the appropriate color
+  def render_visited
+    state.visited.each_key do |cell|
+      outputs.solids << [scale_up(cell), visited_color]
+    end
+  end
+
+  # Renders the star
+  def render_star
+    outputs.sprites << [scale_up(state.star), 'star.png']
+  end
+
+  # Cells have a number rendered in them based on when they were explored
+  # This is based off of their index in the cell_numbers array
+  # Cells are added to this array the same time they are added to the frontier array
+  def render_cell_numbers
+    state.cell_numbers.each_with_index do |cell, index|
+      # Math that approx centers the number in the cell
+      label_x = (cell.x * grid.cell_size) + grid.cell_size / 2 - 5
+      label_y = (cell.y * grid.cell_size) + (grid.cell_size / 2) + 5
+
+      outputs.labels << [label_x, label_y, (index + 1).to_s]
+    end
+  end
+
+  # The next frontier to be expanded is highlighted yellow
+  # Its adjacent non-wall neighbors have their border highlighted green
+  # This is to show the user how the search expands
+  def render_highlights
+    return if state.frontier.empty?
+
+    # Highlight the next frontier to be expanded yellow
+    next_frontier = state.frontier[0]
+    outputs.solids << [scale_up(next_frontier), highlighter_yellow]
+
+    # Neighbors have a semi-transparent green layer over them
+    # Unless the neighbor is a wall
+    adjacent_neighbors(next_frontier).each do |neighbor|
+      unless state.walls.has_key?(neighbor)
+        outputs.solids << [scale_up(neighbor), highlighter_green, 70]
+      end
+    end
+  end
+
+
+  # Cell Size is used when rendering to allow the grid to be scaled up or down
+  # Cells in the frontier array and visited hash and walls hash are stored as x & y
+  # Scaling up cells and lines when rendering allows omitting of width and height
+  def scale_up(cell)
+    # Prevents the original value of cell from being edited
+    cell = cell.clone
+
+    # If cell is just an x and y coordinate
+    if cell.size == 2
+      # Add a width and height of 1
+      cell << 1
+      cell << 1
     end
+
+    # Scale all the values up
+    cell.map! { |value| value * grid.cell_size }
+
+    # Returns the scaled up cell
+    cell
   end
 
-  def calc_sprite_selection
-    # Does the transition to bring down the select sprite screen
-    if state.mode == :selecting && state.select_menu.y != 0
-      state.select_menu.y = 0  # sets y position of select menu (shown when 's' is pressed)
-      state.banner_coords.y = 680 # sets y position of Select Sprite banner
-      state.sprite_coords = state.sprite_coords.map do |x, y, w, h|
-        [x, y - 720, w, h] # sets definition of sprites (change '-' to '+' and the sprites can't be seen)
+
+  # This method processes user input every tick
+  # This method allows the user to use the buttons, slider, and edit the grid
+  # There are 2 types of input:
+  #   Button Input
+  #   Click and Drag Input
+  #
+  #   Button Input is used for the backward step and forward step buttons
+  #   Input is detected by mouse up within the bounds of the rect
+  #
+  #   Click and Drag Input is used for moving the star, adding walls,
+  #   removing walls, and the slider
+  #
+  #   When the mouse is down on the star, the click_and_drag variable is set to :star
+  #   While click_and_drag equals :star, the cursor's position is used to calculate the
+  #   appropriate drag behavior
+  #
+  #   When the mouse goes up click_and_drag is set to :none
+  #
+  #   A variable has to be used because the star has to continue being edited even
+  #   when the cursor is no longer over the star
+  #
+  #   Similar things occur for the other Click and Drag inputs
+  def input
+    # Processes inputs for the buttons
+    input_buttons
+
+    # Detects which if any click and drag input is occurring
+    detect_click_and_drag
+
+    # Does the appropriate click and drag input based on the click_and_drag variable
+    process_click_and_drag
+  end
+
+  # Detects and Process input for each button
+  def input_buttons
+    input_left_button
+    input_right_button
+  end
+
+  # Checks if the previous step button is clicked
+  # If it is, it pauses the animation and moves the search one step backward
+  def input_left_button
+    if left_button_clicked?
+      unless state.anim_steps == 0
+        state.anim_steps -= 1
+        recalculate
       end
     end
+  end
 
-    # Does the transition to leave the select sprite screen
-    if state.mode == :creating  && state.select_menu.y != 720
-      state.select_menu.y = 720 # sets y position of select menu (menu is retreated back up)
-      state.banner_coords.y = 1000 # sets y position of Select Sprite banner
-      state.sprite_coords = state.sprite_coords.map do |x, y, w, h|
-        [x, y + 720, w, h] # sets definition of all elements in collection
+  # Checks if the next step button is clicked
+  # If it is, it pauses the animation and moves the search one step forward
+  def input_right_button
+    if right_button_clicked?
+      unless state.anim_steps == state.max_steps
+        state.anim_steps += 1
+        # Although normally recalculate would be called here
+        # because the right button only moves the search forward
+        # We can just do that
+        calc
       end
     end
   end
 
-  def process_inputs
-    # If the state.mode is back and if the menu has retreated back up
-    # call methods that process user inputs
-    if state.mode == :creating
-      process_inputs_player_movement
-      process_inputs_place_tile
-    end
+  # Whenever the user edits the grid,
+  # The search has to be recalculated upto the current step
 
-    # For each sprite_coordinate added, check what sprite was selected
-    if state.mode == :selecting
-      state.sprite_coords.map do |x, y, order| # goes through all sprites in collection
-        # checks that a specific sprite was pressed based on x, y position
-        if inputs.mouse.down && # the && (and) sign means ALL statements must be true for the evaluation to be true
-           inputs.mouse.down.point.x >= x      && # x is greater than or equal to sprite's x and
-           inputs.mouse.down.point.x <= x + 50 && # x is less than or equal to 50 pixels to the right
-           inputs.mouse.down.point.y >= y      && # y is greater than or equal to sprite's y
-           inputs.mouse.down.point.y <= y + 50 # y is less than or equal to 50 pixels up
-          state.sprite_selected = order # sprite is chosen
-        end
-      end
-    end
+  def recalculate
+    # Resets the search
+    state.frontier = []
+    state.visited = {}
+    state.cell_numbers = []
 
-    inputs_export_stage
-    process_inputs_show_available_sprites
+    # Moves the animation forward one step at a time
+    state.anim_steps.times { calc }
   end
 
-  # Moves the player based on the keys they press on their keyboard
-  def process_inputs_player_movement
-    # Sets dx to 0 if the player lets go of arrow keys (player won't move left or right)
-    if inputs.keyboard.key_up.right
-      state.dx = 0
-    elsif inputs.keyboard.key_up.left
-      state.dx = 0
-    end
 
-    # Sets dx to 3 in whatever direction the player chooses when they hold down (or press) the left or right keys
-    if inputs.keyboard.key_held.right
-      state.dx =  3
-    elsif inputs.keyboard.key_held.left
-      state.dx = -3
+  # Determines what the user is clicking and planning on dragging
+  # Click and drag input is initiated by a click on the appropriate item
+  # and ended by mouse up
+  # Storing the value allows the user to continue the same edit as long as the
+  # mouse left click is held
+  def detect_click_and_drag
+    if inputs.mouse.up
+      state.click_and_drag = :none
+    elsif star_clicked?
+      state.click_and_drag = :star
+    elsif wall_clicked?
+      state.click_and_drag = :remove_wall
+    elsif grid_clicked?
+      state.click_and_drag = :add_wall
+    elsif slider_clicked?
+      state.click_and_drag = :slider
+    end
+  end
+
+  # Processes input based on what the user is currently dragging
+  def process_click_and_drag
+    if state.click_and_drag == :slider
+      input_slider
+    elsif state.click_and_drag == :star
+      input_star
+    elsif state.click_and_drag == :remove_wall
+      input_remove_wall
+    elsif state.click_and_drag == :add_wall
+      input_add_wall
+    end
+  end
+
+  # This method is called when the user is dragging the slider
+  # It moves the current animation step to the point represented by the slider
+  def input_slider
+    mouse_x = inputs.mouse.point.x
+
+    # Bounds the mouse_x to the closest x value on the slider line
+    mouse_x = slider.x if mouse_x < slider.x
+    mouse_x = slider.x + slider.w if mouse_x > slider.x + slider.w
+
+    # Sets the current search step to the one represented by the mouse x value
+    # The slider's circle moves due to the render_slider method using anim_steps
+    state.anim_steps = ((mouse_x - slider.x) / slider.spacing).to_i
+
+    recalculate
+  end
+
+  # Moves the star to the grid closest to the mouse
+  # Only recalculates the search if the star changes position
+  # Called whenever the user is dragging the star
+  def input_star
+    old_star = state.star.clone
+    state.star = cell_closest_to_mouse
+    unless old_star == state.star
+      recalculate
+    end
+  end
+
+  # Removes walls that are under the cursor
+  def input_remove_wall
+    # The mouse needs to be inside the grid, because we only want to remove walls
+    # the cursor is directly over
+    # Recalculations should only occur when a wall is actually deleted
+    if mouse_inside_grid?
+      if state.walls.has_key?(cell_closest_to_mouse)
+        state.walls.delete(cell_closest_to_mouse)
+        recalculate
+      end
     end
+  end
 
-    # Sets dy to 5 to make the player ~fly~ when they press the space bar on their keyboard
-    if inputs.keyboard.key_held.space
-      state.dy = 5
+  # Adds walls at cells under the cursor
+  def input_add_wall
+    # Adds a wall to the hash
+    # We can use the grid closest to mouse, because the cursor is inside the grid
+    if mouse_inside_grid?
+      unless state.walls.has_key?(cell_closest_to_mouse)
+        state.walls[cell_closest_to_mouse] = true
+        recalculate
+      end
     end
   end
 
-  # Adds tile in the place the user holds down the mouse
-  def process_inputs_place_tile
-    if inputs.mouse.down # if mouse is pressed
-      state.world_lookup = {}
-      x, y = to_coord inputs.mouse.down.point # gets x, y coordinates for the grid
+  # This method moves the search forward one step
+  # When the animation is playing it is called every tick
+  # And called whenever the current step of the animation needs to be recalculated
 
-      # Checks if any coordinates duplicate (already exist in world)
-      if state.world.any? { |existing_x, existing_y, n| existing_x == x && existing_y == y }
-        #erases existing tile space by rejecting them from world
-        state.world = state.world.reject do |existing_x, existing_y, n|
-          existing_x == x && existing_y == y
+  # Moves the search forward one step
+  # Parameter called_from_tick is true if it is called from the tick method
+  # It is false when the search is being recalculated after user editing the grid
+  def calc
+    # The setup to the search
+    # Runs once when the there is no frontier or visited cells
+    if state.frontier.empty? && state.visited.empty?
+      state.frontier << state.star
+      state.visited[state.star] = true
+    end
+
+    # A step in the search
+    unless state.frontier.empty?
+      # Takes the next frontier cell
+      new_frontier = state.frontier.shift
+      # For each of its neighbors
+      adjacent_neighbors(new_frontier).each do |neighbor|
+        # That have not been visited and are not walls
+        unless state.visited.has_key?(neighbor) || state.walls.has_key?(neighbor)
+          # Add them to the frontier and mark them as visited
+          state.frontier << neighbor
+          state.visited[neighbor] = true
+
+          # Also assign them a frontier number
+          state.cell_numbers << neighbor
         end
-      else
-        state.world << [x, y, state.sprite_selected] # If no duplicates, add the sprite
       end
     end
   end
 
-  # Stores/exports world collection's info (coordinates, sprite number) into a file
-  def inputs_export_stage
-    if inputs.keyboard.key_down.e # if "e" is pressed
-      export_string = state.world.map do |x, y, sprite_number| # stores world info in a string
-        "#{x},#{y},#{sprite_number}"                           # using string interpolation
-      end
-      gtk.write_file(MAP_FILE_PATH, export_string.join("\n")) # writes string into a file
-      state.map_saved_at = state.tick_count # frame number (passage of time) when the map was saved
-    end
+
+  # Returns a list of adjacent cells
+  # Used to determine what the next cells to be added to the frontier are
+  def adjacent_neighbors cell
+    neighbors = []
+
+    neighbors << [cell.x, cell.y + 1] unless cell.y == grid.height - 1
+    neighbors << [cell.x + 1, cell.y] unless cell.x == grid.width - 1
+    neighbors << [cell.x, cell.y - 1] unless cell.y == 0
+    neighbors << [cell.x - 1, cell.y] unless cell.x == 0
+
+    neighbors
   end
 
-  def process_inputs_show_available_sprites
-    # Based on keyboard input, the entity (:creating and :selecting) switch
-    if inputs.keyboard.key_held.s && state.mode == :creating # if "s" is pressed and currently creating
-      state.mode = :selecting # will change to selecting
-      inputs.keyboard.clear # VERY IMPORTANT! If not present, it'll flicker between on and off
-    elsif inputs.keyboard.key_held.s && state.mode == :selecting # if "s" is pressed and currently selecting
-      state.mode = :creating # will change to creating
-      inputs.keyboard.clear # VERY IMPORTANT! If not present, it'll flicker between on and off
-    end
+  # When the user grabs the star and puts their cursor to the far right
+  # and moves up and down, the star is supposed to move along the grid as well
+  # Finding the grid closest to the mouse helps with this
+  def cell_closest_to_mouse
+    x = (inputs.mouse.point.x / grid.cell_size).to_i
+    y = (inputs.mouse.point.y / grid.cell_size).to_i
+    x = grid.width - 1 if x > grid.width - 1
+    y = grid.height - 1 if y > grid.height - 1
+    [x, y]
   end
 
-  # Loads the world collection by reading from the map.txt file in the app folder
-  def attempt_load_world_from_file
-    return if state.world # return if the world collection is already populated
-    state.world ||= [] # initialized as an empty collection
-    exported_world = gtk.read_file(MAP_FILE_PATH) # reads the file using the path mentioned at top of code
-    return unless exported_world # return unless the file read was successful
-    state.world = exported_world.each_line.map do |l| # perform action on each line of exported_world
-        l.split(',').map(&:to_i) # calls split using ',' as a delimiter, and invokes .map on the collection,
-                                 # calling to_i (converts to integers) on each element
-    end
+
+  # These methods detect when the buttons are clicked
+  def left_button_clicked?
+    (inputs.mouse.up && inputs.mouse.point.inside_rect?(buttons.left)) || inputs.keyboard.key_up.left
   end
 
-  # Adds the change in y to y to determine the next y position of the player.
-  def next_y
-    state.y + state.dy
+  def right_button_clicked?
+    (inputs.mouse.up && inputs.mouse.point.inside_rect?(buttons.right)) || inputs.keyboard.key_up.right
   end
 
-  # Determines next x position of player
-  def next_x
-    if state.dx < 0 # if the player moves left
-      return state.x - (state.tile_size - state.player_width) # subtracts since the change in x is negative (player is moving left)
-    else
-      return state.x + (state.tile_size - state.player_width) # adds since the change in x is positive (player is moving right)
+  # Signal that the user is going to be moving the slider
+  def slider_clicked?
+    circle_x = (slider.x - slider.offset) + (state.anim_steps * slider.spacing)
+    circle_y = (slider.y - slider.offset)
+    circle_rect = [circle_x, circle_y, 37, 37]
+    inputs.mouse.down && inputs.mouse.point.inside_rect?(circle_rect)
+  end
+
+  # Signal that the user is going to be moving the star
+  def star_clicked?
+    inputs.mouse.down && inputs.mouse.point.inside_rect?(scale_up(state.star))
+  end
+
+  # Signal that the user is going to be removing walls
+  def wall_clicked?
+    inputs.mouse.down && mouse_inside_a_wall?
+  end
+
+  # Signal that the user is going to be adding walls
+  def grid_clicked?
+    inputs.mouse.down && mouse_inside_grid?
+  end
+
+  # Returns whether the mouse is inside of a wall
+  # Part of the condition that checks whether the user is removing a wall
+  def mouse_inside_a_wall?
+    state.walls.each_key do | wall |
+      return true if inputs.mouse.point.inside_rect?(scale_up(wall))
     end
+
+    false
   end
 
-  def to_coord point
-    # Integer divides (idiv) point.x to turn into grid
-    # Then, you can just multiply each integer by state.tile_size
-    # later and huzzah. Grid coordinates
-    [point.x.idiv(state.tile_size), point.y.idiv(state.tile_size)]
+  # Returns whether the mouse is inside of a grid
+  # Part of the condition that checks whether the user is adding a wall
+  def mouse_inside_grid?
+    inputs.mouse.point.inside_rect?(scale_up([0, 0, grid.width, grid.height]))
   end
-end
 
-$metroidvania_starter = MetroidvaniaStarter.new
+  # These methods provide handy aliases to colors
 
-def tick args
-    $metroidvania_starter.grid    = args.grid
-    $metroidvania_starter.inputs  = args.inputs
-    $metroidvania_starter.state   = args.state
-    $metroidvania_starter.outputs = args.outputs
-    $metroidvania_starter.gtk     = args.gtk
-    $metroidvania_starter.tick
-end
+  # Light brown
+  def unvisited_color
+    [221, 212, 213]
+  end
 
-

-Physics And Collisions - Jump Physics - main.rb
-# ./samples/04_physics_and_collisions/06_jump_physics/app/main.rb
-=begin
+  # Black
+  def grid_line_color
+    [255, 255, 255]
+  end
 
- Reminders:
+  # Dark Brown
+  def visited_color
+    [204, 191, 179]
+  end
 
- - args.state.new_entity: Used when we want to create a new object, like a sprite or button.
-   For example, if we want to create a new button, we would declare it as a new entity and
-   then define its properties. (Remember, you can use state to define ANY property and it will
-   be retained across frames.)
+  # Blue
+  def frontier_color
+    [103, 136, 204]
+  end
 
- - args.outputs.solids: An array. The values generate a solid.
-   The parameters for a solid are [X, Y, WIDTH, HEIGHT, RED, GREEN, BLUE]
-   For more information about solids, go to mygame/documentation/03-solids-and-borders.md.
+  # Camo Green
+  def wall_color
+    [134, 134, 120]
+  end
 
- - num1.greater(num2): Returns the greater value.
+  # Next frontier to be expanded
+  def highlighter_yellow
+    [214, 231, 125]
+  end
 
- - Hashes: Collection of unique keys and their corresponding values. The value can be found
-   using their keys.
+  # The neighbors of the next frontier to be expanded
+  def highlighter_green
+    [65, 191, 127]
+  end
 
- - ARRAY#inside_rect?: Returns true or false depending on if the point is inside the rect.
+  # Button background
+  def gray
+    [190, 190, 190]
+  end
 
-=end
+  # Button outline
+  def black
+    [0, 0, 0]
+  end
 
-# This sample app is a game that requires the user to jump from one platform to the next.
-# As the player successfully clears platforms, they become smaller and move faster.
+  # These methods make the code more concise
+  def grid
+    state.grid
+  end
 
-class VerticalPlatformer
-  attr_gtk
+  def buttons
+    state.buttons
+  end
 
-  # declares vertical platformer as new entity
-  def s
-    state.vertical_platformer ||= state.new_entity(:vertical_platformer)
-    state.vertical_platformer
+  def slider
+    state.slider
   end
+end
 
-  # creates a new platform using a hash
-  def new_platform hash
-    s.new_entity_strict(:platform, hash) # platform key
+
+def tick args
+  # Pressing r resets the program
+  if args.inputs.keyboard.key_down.r
+    args.gtk.reset
+    reset
+    return
   end
 
-  # calls methods needed for game to run properly
+  $detailed_breadth_first_search ||= DetailedBreadthFirstSearch.new(args)
+  $detailed_breadth_first_search.args = args
+  $detailed_breadth_first_search.tick
+end
+
+
+def reset
+  $detailed_breadth_first_search = nil
+end
+
+
+Path Finding Algorithms - Breadcrumbs - main.rb
+# ./samples/13_path_finding_algorithms/03_breadcrumbs/app/main.rb
+class Breadcrumbs
+  attr_gtk
+
+  # This method is called every frame/tick
+  # Every tick, the current state of the search is rendered on the screen,
+  # User input is processed, and
+  # The next step in the search is calculated
   def tick
     defaults
+    # If the grid has not been searched
+    if search.came_from.empty?
+      calc
+      # Calc Path
+    end
     render
-    calc
     input
   end
 
-  # Sets default values
   def defaults
-    s.platforms ||= [ # initializes platforms collection with two platforms using hashes
-      new_platform(x: 0, y: 0, w: 700, h: 32, dx: 1, speed: 0, rect: nil),
-      new_platform(x: 0, y: 300, w: 700, h: 32, dx: 1, speed: 0, rect: nil), # 300 pixels higher
-    ]
+    # Variables to edit the size and appearance of the grid
+    # Freely customizable to user's liking
+    grid.width     ||= 30
+    grid.height    ||= 15
+    grid.cell_size ||= 40
+    grid.rect      ||= [0, 0, grid.width, grid.height]
+
+    # The location of the star and walls of the grid
+    # They can be modified to have a different initial grid
+    # Walls are stored in a hash for quick look up when doing the search
+    grid.star   ||= [2, 8]
+    grid.target ||= [10, 5]
+    grid.walls  ||= {
+      [3, 3] => true,
+      [3, 4] => true,
+      [3, 5] => true,
+      [3, 6] => true,
+      [3, 7] => true,
+      [3, 8] => true,
+      [3, 9] => true,
+      [3, 10] => true,
+      [3, 11] => true,
+      [4, 3] => true,
+      [4, 4] => true,
+      [4, 5] => true,
+      [4, 6] => true,
+      [4, 7] => true,
+      [4, 8] => true,
+      [4, 9] => true,
+      [4, 10] => true,
+      [4, 11] => true,
+      [13, 0] => true,
+      [13, 1] => true,
+      [13, 2] => true,
+      [13, 3] => true,
+      [13, 4] => true,
+      [13, 5] => true,
+      [13, 6] => true,
+      [13, 7] => true,
+      [13, 8] => true,
+      [13, 9] => true,
+      [13, 10] => true,
+      [14, 0] => true,
+      [14, 1] => true,
+      [14, 2] => true,
+      [14, 3] => true,
+      [14, 4] => true,
+      [14, 5] => true,
+      [14, 6] => true,
+      [14, 7] => true,
+      [14, 8] => true,
+      [14, 9] => true,
+      [14, 10] => true,
+      [21, 8] => true,
+      [21, 9] => true,
+      [21, 10] => true,
+      [21, 11] => true,
+      [21, 12] => true,
+      [21, 13] => true,
+      [21, 14] => true,
+      [22, 8] => true,
+      [22, 9] => true,
+      [22, 10] => true,
+      [22, 11] => true,
+      [22, 12] => true,
+      [22, 13] => true,
+      [22, 14] => true,
+      [23, 8] => true,
+      [23, 9] => true,
+      [24, 8] => true,
+      [24, 9] => true,
+      [25, 8] => true,
+      [25, 9] => true,
+    }
 
-    s.tick_count  = args.state.tick_count
-    s.gravity     = -0.3 # what goes up must come down because of gravity
-    s.player.platforms_cleared ||= 0 # counts how many platforms the player has successfully cleared
-    s.player.x  ||= 0           # sets player values
-    s.player.y  ||= 100
-    s.player.w  ||= 64
-    s.player.h  ||= 64
-    s.player.dy ||= 0           # change in position
-    s.player.dx ||= 0
-    s.player_jump_power           = 15
-    s.player_jump_power_duration  = 10
-    s.player_max_run_speed        = 5
-    s.player_speed_slowdown_rate  = 0.9
-    s.player_acceleration         = 1
-    s.camera ||= { y: -100 } # shows view on screen (as the player moves upward, the camera does too)
+    # Variables that are used by the breadth first search
+    # Storing cells that the search has visited, prevents unnecessary steps
+    # Expanding the frontier of the search in order makes the search expand
+    # from the center outward
+
+    # The cells from which the search is to expand
+    search.frontier              ||= []
+    # A hash of where each cell was expanded from
+    # The key is a cell, and the value is the cell it came from
+    search.came_from             ||= {}
+    # Cells that are part of the path from the target to the star
+    search.path                  ||= {}
+
+    # What the user is currently editing on the grid
+    # We store this value, because we want to remember the value even when
+    # the user's cursor is no longer over what they're interacting with, but
+    # they are still clicking down on the mouse.
+    state.current_input ||= :none
   end
 
-  # Outputs objects onto the screen
+  def calc
+    # Setup the search to start from the star
+    search.frontier << grid.star
+    search.came_from[grid.star] = nil
+
+    # Until there are no more cells to expand from
+    until search.frontier.empty?
+      # Takes the next frontier cell
+      new_frontier = search.frontier.shift
+      # For each of its neighbors
+      adjacent_neighbors(new_frontier).each do |neighbor|
+        # That have not been visited and are not walls
+        unless search.came_from.has_key?(neighbor) || grid.walls.has_key?(neighbor)
+          # Add them to the frontier and mark them as visited in the first grid
+          # Unless the target has been visited
+          # Add the neighbor to the frontier and remember which cell it came from
+          search.frontier << neighbor
+          search.came_from[neighbor] = new_frontier
+        end
+      end
+    end
+  end
+
+
+  # Draws everything onto the screen
   def render
-    outputs.solids << s.platforms.map do |p| # outputs platforms onto screen
-      [p.x + 300, p.y - s.camera[:y], p.w, p.h] # add 300 to place platform in horizontal center
-      # don't forget, position of platform is denoted by bottom left hand corner
+    render_background
+    # render_heat_map
+    render_walls
+    # render_path
+    # render_labels
+    render_arrows
+    render_star
+    render_target
+    unless grid.walls.has_key?(grid.target)
+      render_trail
+    end
+  end
+
+  def render_trail(current_cell=grid.target)
+    return if current_cell == grid.star
+    parent_cell = search.came_from[current_cell]
+    if current_cell && parent_cell
+      outputs.lines << [(current_cell.x + 0.5) * grid.cell_size, (current_cell.y + 0.5) * grid.cell_size,
+      (parent_cell.x + 0.5) * grid.cell_size, (parent_cell.y + 0.5) * grid.cell_size, purple]
+
+    end
+    render_trail(parent_cell)
+  end
+
+  def render_arrows
+    search.came_from.each do |child, parent|
+      if parent && child
+        arrow_cell = [(child.x + parent.x) / 2, (child.y + parent.y) / 2]
+        if parent.x > child.x # If the parent cell is to the right of the child cell
+          outputs.sprites << [scale_up(arrow_cell), 'arrow.png', 0] # Point the arrow to the right
+        elsif parent.x < child.x # If the parent cell is to the right of the child cell
+          outputs.sprites << [scale_up(arrow_cell), 'arrow.png', 180] # Point the arrow to the right
+        elsif parent.y > child.y # If the parent cell is to the right of the child cell
+          outputs.sprites << [scale_up(arrow_cell), 'arrow.png', 90] # Point the arrow to the right
+        elsif parent.y < child.y # If the parent cell is to the right of the child cell
+          outputs.sprites << [scale_up(arrow_cell), 'arrow.png', 270] # Point the arrow to the right
+        end
+      end
     end
+  end
 
-    # outputs player using hash
-    outputs.solids << {
-      x: s.player.x + 300, # player positioned on top of platform
-      y: s.player.y - s.camera[:y],
-      w: s.player.w,
-      h: s.player.h,
-      r: 100,              # color saturation
-      g: 100,
-      b: 200
-    }
+  # The methods below subdivide the task of drawing everything to the screen
+
+  # Draws what the grid looks like with nothing on it
+  def render_background
+    render_unvisited
+    render_grid_lines
   end
 
-  # Performs calculations
-  def calc
-    s.platforms.each do |p| # for each platform in the collection
-      p.rect = [p.x, p.y, p.w, p.h] # set the definition
+  # Draws both grids
+  def render_unvisited
+    outputs.solids << [scale_up(grid.rect), unvisited_color]
+  end
+
+  # Draws grid lines to show the division of the grid into cells
+  def render_grid_lines
+    for x in 0..grid.width
+      outputs.lines << vertical_line(x)
     end
 
-    # sets player point by adding half the player's width to the player's x
-    s.player.point = [s.player.x + s.player.w.half, s.player.y] # change + to - and see what happens!
+    for y in 0..grid.height
+      outputs.lines << horizontal_line(y)
+    end
+  end
 
-    # search the platforms collection to find if the player's point is inside the rect of a platform
-    collision = s.platforms.find { |p| s.player.point.inside_rect? p.rect }
+  # Easy way to draw vertical lines given an index
+  def vertical_line column
+    scale_up([column, 0, column, grid.height])
+  end
 
-    # if collision occurred and player is moving down (or not moving vertically at all)
-    if collision && s.player.dy <= 0
-      s.player.y = collision.rect.y + collision.rect.h - 2 # player positioned on top of platform
-      s.player.dy = 0 if s.player.dy < 0 # player stops moving vertically
-      if !s.player.platform
-        s.player.dx = 0 # no horizontal movement
-      end
-      # changes horizontal position of player by multiplying collision change in x (dx) by speed and adding it to current x
-      s.player.x += collision.dx * collision.speed
-      s.player.platform = collision # player is on the platform that it collided with (or landed on)
-      if s.player.falling # if player is falling
-        s.player.dx = 0  # no horizontal movement
-      end
-      s.player.falling = false
-      s.player.jumped_at = nil
-    else
-      s.player.platform = nil # player is not on a platform
-      s.player.y  += s.player.dy # velocity is the change in position
-      s.player.dy += s.gravity # acceleration is the change in velocity; what goes up must come down
+  # Easy way to draw horizontal lines given an index
+  def horizontal_line row
+    scale_up([0, row, grid.width, row])
+  end
+
+  # Draws the walls on both grids
+  def render_walls
+    grid.walls.each_key do |wall|
+      outputs.solids << [scale_up(wall), wall_color]
     end
+  end
 
-    s.platforms.each do |p| # for each platform in the collection
-      p.x += p.dx * p.speed # x is incremented by product of dx and speed (causes platform to move horizontally)
-      # changes platform's x so it moves left and right across the screen (between -300 and 300 pixels)
-      if p.x < -300 # if platform goes too far left
-        p.dx *= -1 # dx is scaled down
-        p.x = -300 # as far left as possible within scope
-      elsif p.x > (1000 - p.w) # if platform's x is greater than 300
-        p.dx *= -1
-        p.x = (1000 - p.w) # set to 300 (as far right as possible within scope)
+  # Renders the star on both grids
+  def render_star
+    outputs.sprites << [scale_up(grid.star), 'star.png']
+  end
+
+  # Renders the target on both grids
+  def render_target
+    outputs.sprites << [scale_up(grid.target), 'target.png']
+  end
+
+  # Labels the grids
+  def render_labels
+    outputs.labels << [200, 625, "Without early exit"]
+  end
+
+  # Renders the path based off of the search.path hash
+  def render_path
+    # If the star and target are disconnected there will only be one path
+    # The path should not render in that case
+    unless search.path.size == 1
+      search.path.each_key do | cell |
+        # Renders path on both grids
+        outputs.solids << [scale_up(cell), path_color]
       end
     end
+  end
 
-    delta = (s.player.y - s.camera[:y] - 100) # used to position camera view
+  # Calculates the path from the target to the star after the search is over
+  # Relies on the came_from hash
+  # Fills the search.path hash, which is later rendered on screen
+  def calc_path
+    endpoint = grid.target
+    while endpoint
+      search.path[endpoint] = true
+      endpoint = search.came_from[endpoint]
+    end
+  end
 
-    if delta > -200
-      s.camera[:y] += delta * 0.01 # allows player to see view as they move upwards
-      s.player.x  += s.player.dx # velocity is change in position; change in x increases by dx
+  # In code, the cells are represented as 1x1 rectangles
+  # When drawn, the cells are larger than 1x1 rectangles
+  # This method is used to scale up cells, and lines
+  # Objects are scaled up according to the grid.cell_size variable
+  # This allows for easy customization of the visual scale of the grid
+  def scale_up(cell)
+    # Prevents the original value of cell from being edited
+    cell = cell.clone
 
-      # searches platform collection to find platforms located more than 300 pixels above the player
-      has_platforms = s.platforms.find { |p| p.y > (s.player.y + 300) }
-      if !has_platforms # if there are no platforms 300 pixels above the player
-        width = 700 - (700 * (0.1 * s.player.platforms_cleared)) # the next platform is smaller than previous
-        s.player.platforms_cleared += 1 # player successfully cleared another platform
-        last_platform = s.platforms[-1] # platform just cleared becomes last platform
-        # another platform is created 300 pixels above the last platform, and this
-        # new platform has a smaller width and moves faster than all previous platforms
-        s.platforms << new_platform(x: (700 - width) * rand, # random x position
-                                    y: last_platform.y + 300,
-                                    w: width,
-                                    h: 32,
-                                    dx: 1.randomize(:sign), # random change in x
-                                    speed: 2 * s.player.platforms_cleared,
-                                    rect: nil)
-      end
-    else
-      s.as_hash.clear # otherwise clear the hash (no new platform is necessary)
+    # If cell is just an x and y coordinate
+    if cell.size == 2
+      # Add a width and height of 1
+      cell << 1
+      cell << 1
     end
+
+    # Scale all the values up
+    cell.map! { |value| value * grid.cell_size }
+
+    # Returns the scaled up cell
+    cell
   end
 
-  # Takes input from the user to move the player
+  # This method processes user input every tick
+  # Any method with "1" is related to the first grid
+  # Any method with "2" is related to the second grid
   def input
-    if inputs.keyboard.space # if the space bar is pressed
-      s.player.jumped_at ||= s.tick_count # set to current frame
+    # The program has to remember that the user is dragging an object
+    # even when the mouse is no longer over that object
+    # So detecting input and processing input is separate
+    # detect_input
+    # process_input
+    if inputs.mouse.up
+      state.current_input = :none
+    elsif star_clicked?
+      state.current_input = :star
+    end
 
-      # if the time that has passed since the jump is less than the duration of a jump (10 frames)
-      # and the player is not falling
-      if s.player.jumped_at.elapsed_time < s.player_jump_power_duration && !s.player.falling
-        s.player.dy = s.player_jump_power # player jumps up
+    if mouse_inside_grid?
+      unless grid.target == cell_closest_to_mouse
+        grid.target = cell_closest_to_mouse
+      end
+      if state.current_input == :star
+        unless grid.star == cell_closest_to_mouse
+          grid.star = cell_closest_to_mouse
+        end
       end
     end
+  end
 
-    if inputs.keyboard.key_up.space # if space bar is in "up" state
-      s.player.falling = true # player is falling
+  # Determines what the user is editing and stores the value
+  # Storing the value allows the user to continue the same edit as long as the
+  # mouse left click is held
+  def detect_input
+    # When the mouse is up, nothing is being edited
+    if inputs.mouse.up
+      state.current_input = :none
+    # When the star in the no second grid is clicked
+    elsif star_clicked?
+      state.current_input = :star
+    # When the target in the no second grid is clicked
+    elsif target_clicked?
+      state.current_input = :target
+    # When a wall in the first grid is clicked
+    elsif wall_clicked?
+      state.current_input = :remove_wall
+    # When the first grid is clicked
+    elsif grid_clicked?
+      state.current_input = :add_wall
+    end
+  end
+
+  # Processes click and drag based on what the user is currently dragging
+  def process_input
+    if state.current_input == :star
+      input_star
+    elsif state.current_input == :target
+      input_target
+    elsif state.current_input == :remove_wall
+      input_remove_wall
+    elsif state.current_input == :add_wall
+      input_add_wall
+    end
+  end
+
+  # Moves the star to the cell closest to the mouse in the first grid
+  # Only resets the search if the star changes position
+  # Called whenever the user is editing the star (puts mouse down on star)
+  def input_star
+    old_star = grid.star.clone
+    grid.star = cell_closest_to_mouse
+    unless old_star == grid.star
+      reset_search
+    end
+  end
+
+  # Moves the target to the grid closest to the mouse in the first grid
+  # Only reset_searchs the search if the target changes position
+  # Called whenever the user is editing the target (puts mouse down on target)
+  def input_target
+    old_target = grid.target.clone
+    grid.target = cell_closest_to_mouse
+    unless old_target == grid.target
+      reset_search
+    end
+  end
+
+  # Removes walls in the first grid that are under the cursor
+  def input_remove_wall
+    # The mouse needs to be inside the grid, because we only want to remove walls
+    # the cursor is directly over
+    # Recalculations should only occur when a wall is actually deleted
+    if mouse_inside_grid?
+      if grid.walls.has_key?(cell_closest_to_mouse)
+        grid.walls.delete(cell_closest_to_mouse)
+        reset_search
+      end
     end
+  end
 
-    if inputs.keyboard.left # if left key is pressed
-      s.player.dx -= s.player_acceleration # player's position changes, decremented by acceleration
-      s.player.dx = s.player.dx.greater(-s.player_max_run_speed) # dx is either current dx or -5, whichever is greater
-    elsif inputs.keyboard.right # if right key is pressed
-      s.player.dx += s.player_acceleration # player's position changes, incremented by acceleration
-      s.player.dx  = s.player.dx.lesser(s.player_max_run_speed) # dx is either current dx or 5, whichever is lesser
-    else
-      s.player.dx *= s.player_speed_slowdown_rate # scales dx down
+  # Adds a wall in the first grid in the cell the mouse is over
+  def input_add_wall
+    if mouse_inside_grid?
+      unless grid.walls.has_key?(cell_closest_to_mouse)
+        grid.walls[cell_closest_to_mouse] = true
+        reset_search
+      end
     end
   end
-end
 
-$game = VerticalPlatformer.new
 
-def tick args
-  $game.args = args
-  $game.tick
-end
+  # Whenever the user edits the grid,
+  # The search has to be reset_searchd upto the current step
+  # with the current grid as the initial state of the grid
+  def reset_search
+    # Reset_Searchs the search
+    search.frontier  = []
+    search.came_from = {}
+    search.path      = {}
+  end
 
-

-Mouse - Mouse Click - main.rb
-# ./samples/05_mouse/01_mouse_click/app/main.rb
-=begin
 
- APIs listing that haven't been encountered in previous sample apps:
+  # Returns a list of adjacent cells
+  # Used to determine what the next cells to be added to the frontier are
+  def adjacent_neighbors(cell)
+    neighbors = []
 
- - product: Returns an array of all combinations of elements from all arrays.
+    # Gets all the valid neighbors into the array
+    # From southern neighbor, clockwise
+    neighbors << [cell.x, cell.y - 1] unless cell.y == 0
+    neighbors << [cell.x - 1, cell.y] unless cell.x == 0
+    neighbors << [cell.x, cell.y + 1] unless cell.y == grid.height - 1
+    neighbors << [cell.x + 1, cell.y] unless cell.x == grid.width - 1
 
-   For example, [1,2].product([1,2]) would return the following array...
-   [[1,1], [1,2], [2,1], [2,2]]
-   More than two arrays can be given to product and it will still work,
-   such as [1,2].product([1,2],[3,4]). What would product return in this case?
+    # Sorts the neighbors so the rendered path is a zigzag path
+    # Cells in a diagonal direction are given priority
+    # Comment this line to see the difference
+    neighbors = neighbors.sort_by { |neighbor_x, neighbor_y|  proximity_to_star(neighbor_x, neighbor_y) }
 
-   Answer:
-   [[1,1,3],[1,1,4],[1,2,3],[1,2,4],[2,1,3],[2,1,4],[2,2,3],[2,2,4]]
+    neighbors
+  end
 
- - num1.fdiv(num2): Returns the float division (will have a decimal) of the two given numbers.
-   For example, 5.fdiv(2) = 2.5 and 5.fdiv(5) = 1.0
+  # Finds the vertical and horizontal distance of a cell from the star
+  # and returns the larger value
+  # This method is used to have a zigzag pattern in the rendered path
+  # A cell that is [5, 5] from the star,
+  # is explored before over a cell that is [0, 7] away.
+  # So, if possible, the search tries to go diagonal (zigzag) first
+  def proximity_to_star(x, y)
+    distance_x = (grid.star.x - x).abs
+    distance_y = (grid.star.y - y).abs
 
- - yield: Allows you to call a method with a code block and yield to that block.
+    if distance_x > distance_y
+      return distance_x
+    else
+      return distance_y
+    end
+  end
 
- Reminders:
+  # When the user grabs the star and puts their cursor to the far right
+  # and moves up and down, the star is supposed to move along the grid as well
+  # Finding the cell closest to the mouse helps with this
+  def cell_closest_to_mouse
+    # Closest cell to the mouse in the first grid
+    x = (inputs.mouse.point.x / grid.cell_size).to_i
+    y = (inputs.mouse.point.y / grid.cell_size).to_i
+    # Bound x and y to the grid
+    x = grid.width - 1 if x > grid.width - 1
+    y = grid.height - 1 if y > grid.height - 1
+    # Return closest cell
+    [x, y]
+  end
 
- - ARRAY#inside_rect?: Returns true or false depending on if the point is inside the rect.
+  # Signal that the user is going to be moving the star from the first grid
+  def star_clicked?
+    inputs.mouse.down && inputs.mouse.point.inside_rect?(scale_up(grid.star))
+  end
 
- - String interpolation: Uses #{} syntax; everything between the #{ and the } is evaluated
-   as Ruby code, and the placeholder is replaced with its corresponding value or result.
+  # Signal that the user is going to be moving the target from the first grid
+  def target_clicked?
+    inputs.mouse.down && inputs.mouse.point.inside_rect?(scale_up(grid.target))
+  end
 
- - args.inputs.mouse.click: This property will be set if the mouse was clicked.
+  # Signal that the user is going to be adding walls from the first grid
+  def grid_clicked?
+    inputs.mouse.down && mouse_inside_grid?
+  end
 
- - Ternary operator (?): Will evaluate a statement (just like an if statement)
-   and perform an action if the result is true or another action if it is false.
+  # Returns whether the mouse is inside of the first grid
+  # Part of the condition that checks whether the user is adding a wall
+  def mouse_inside_grid?
+    inputs.mouse.point.inside_rect?(scale_up(grid.rect))
+  end
 
- - reject: Removes elements from a collection if they meet certain requirements.
+  # These methods provide handy aliases to colors
 
- - args.outputs.borders: An array. The values generate a border.
-   The parameters are [X, Y, WIDTH, HEIGHT, RED, GREEN, BLUE]
-   For more information about borders, go to mygame/documentation/03-solids-and-borders.md.
+  # Light brown
+  def unvisited_color
+    [221, 212, 213]
+    # [255, 255, 255]
+  end
 
- - args.outputs.labels: An array. The values generate a label.
-   The parameters are [X, Y, TEXT, SIZE, ALIGNMENT, RED, GREEN, BLUE, ALPHA, FONT STYLE]
-   For more information about labels, go to mygame/documentation/02-labels.
+  # Camo Green
+  def wall_color
+    [134, 134, 120]
+  end
 
-=end
+  # Pastel White
+  def path_color
+    [231, 230, 228]
+  end
 
-# This sample app is a classic game of Tic Tac Toe.
+  def red
+    [255, 0, 0]
+  end
 
-class TicTacToe
-  attr_accessor :_, :state, :outputs, :inputs, :grid, :gtk
+  def purple
+    [149, 64, 191]
+  end
 
-  # Starts the game with player x's turn and creates an array (to_a) for space combinations.
-  # Calls methods necessary for the game to run properly.
+  # Makes code more concise
+  def grid
+    state.grid
+  end
+
+  def search
+    state.search
+  end
+end
+
+# Method that is called by DragonRuby periodically
+# Used for updating animations and calculations
+def tick args
+
+  # Pressing r will reset the application
+  if args.inputs.keyboard.key_down.r
+    args.gtk.reset
+    reset
+    return
+  end
+
+  # Every tick, new args are passed, and the Breadth First Search tick is called
+  $breadcrumbs ||= Breadcrumbs.new(args)
+  $breadcrumbs.args = args
+  $breadcrumbs.tick
+end
+
+
+def reset
+  $breadcrumbs = nil
+end
+
+ #  # Representation of how far away visited cells are from the star
+ #  # Replaces the render_visited method
+ #  # Visually demonstrates the effectiveness of early exit for pathfinding
+ #  def render_heat_map
+ #    # THIS CODE NEEDS SOME FIXING DUE TO REFACTORING
+ #    search.came_from.each_key do | cell |
+ #      distance = (grid.star.x - visited_cell.x).abs + (state.star.y - visited_cell.y).abs
+ #      max_distance = grid.width + grid.height
+ #      alpha = 255.to_i * distance.to_i / max_distance.to_i
+ #      outputs.solids << [scale_up(visited_cell), red, alpha]
+ #      # outputs.solids << [early_exit_scale_up(visited_cell), red, alpha]
+ #    end
+ #  end
+
+
+Path Finding Algorithms - Early Exit - main.rb
+# ./samples/13_path_finding_algorithms/04_early_exit/app/main.rb
+# Comparison of a breadth first search with and without early exit
+# Inspired by https://www.redblobgames.com/pathfinding/a-star/introduction.html
+
+# Demonstrates the exploration difference caused by early exit
+# Also demonstrates how breadth first search is used for path generation
+
+# The left grid is a breadth first search without early exit
+# The right grid is a breadth first search with early exit
+# The red squares represent how far the search expanded
+# The darker the red, the farther the search proceeded
+# Comparison of the heat map reveals how much searching can be saved by early exit
+# The white path shows path generation via breadth first search
+class EarlyExitBreadthFirstSearch
+  attr_gtk
+
+  # This method is called every frame/tick
+  # Every tick, the current state of the search is rendered on the screen,
+  # User input is processed, and
+  # The next step in the search is calculated
   def tick
-    state.current_turn ||= :x
-    state.space_combinations = [-1, 0, 1].product([-1, 0, 1]).to_a
-    render_board
-    input_board
+    defaults
+    # If the grid has not been searched
+    if state.visited.empty?
+      # Complete the search
+      state.max_steps.times { step }
+      # And calculate the path
+      calc_path
+    end
+    render
+    input
   end
 
-  # Uses borders to create grid squares for the game's board. Also outputs the game pieces using labels.
-  def render_board
-    square_size = 80
+  def defaults
+    # Variables to edit the size and appearance of the grid
+    # Freely customizable to user's liking
+    grid.width     ||= 15
+    grid.height    ||= 15
+    grid.cell_size ||= 40
+    grid.rect      ||= [0, 0, grid.width, grid.height]
+
+    # At some step the animation will end,
+    # and further steps won't change anything (the whole grid.widthill be explored)
+    # This step is roughly the grid's width * height
+    # When anim_steps equals max_steps no more calculations will occur
+    # and the slider will be at the end
+    state.max_steps  ||= args.state.grid.width * args.state.grid.height
+
+    # The location of the star and walls of the grid
+    # They can be modified to have a different initial grid
+    # Walls are stored in a hash for quick look up when doing the search
+    state.star   ||= [2, 8]
+    state.target ||= [10, 5]
+    state.walls  ||= {}
+
+    # Variables that are used by the breadth first search
+    # Storing cells that the search has visited, prevents unnecessary steps
+    # Expanding the frontier of the search in order makes the search expand
+    # from the center outward
+
+    # Visited cells in the first grid
+    state.visited               ||= {}
+    # Visited cells in the second grid
+    state.early_exit_visited    ||= {}
+    # The cells from which the search is to expand
+    state.frontier              ||= []
+    # A hash of where each cell was expanded from
+    # The key is a cell, and the value is the cell it came from
+    state.came_from             ||= {}
+    # Cells that are part of the path from the target to the star
+    state.path                  ||= {}
+
+    # What the user is currently editing on the grid
+    # We store this value, because we want to remember the value even when
+    # the user's cursor is no longer over what they're interacting with, but
+    # they are still clicking down on the mouse.
+    state.current_input ||= :none
+  end
+
+  # Draws everything onto the screen
+  def render
+    render_background
+    render_heat_map
+    render_walls
+    render_path
+    render_star
+    render_target
+    render_labels
+  end
 
-    # Positions the game's board in the center of the screen.
-    # Try removing what follows grid.w_half or grid.h_half and see how the position changes!
-    board_left = grid.w_half - square_size * 1.5
-    board_top  = grid.h_half - square_size * 1.5
+  # The methods below subdivide the task of drawing everything to the screen
 
-    # At first glance, the add(1) looks pretty trivial. But if you remove it,
-    # you'll see that the positioning of the board would be skewed without it!
-    # Or if you put 2 in the parenthesis, the pieces will be placed in the wrong squares
-    # due to the change in board placement.
-    outputs.borders << all_spaces do |x, y, space| # outputs borders for all board spaces
-      space.border ||= [
-        board_left + x.add(1) * square_size, # space.border is initialized using this definition
-        board_top  + y.add(1) * square_size,
-        square_size,
-        square_size
-      ]
+  # Draws what the grid looks like with nothing on it
+  def render_background
+    render_unvisited
+    render_grid_lines
+  end
+
+  # Draws both grids
+  def render_unvisited
+    outputs.solids << [scale_up(grid.rect), unvisited_color]
+    outputs.solids << [early_exit_scale_up(grid.rect), unvisited_color]
+  end
+
+  # Draws grid lines to show the division of the grid into cells
+  def render_grid_lines
+    for x in 0..grid.width
+      outputs.lines << vertical_line(x)
+      outputs.lines << early_exit_vertical_line(x)
     end
 
-    # Again, the calculations ensure that the piece is placed in the center of the grid square.
-    # Remove the '- 20' and the piece will be placed at the top of the grid square instead of the center.
-    outputs.labels << filled_spaces do |x, y, space| # put label in each filled space of board
-          label board_left + x.add(1) * square_size + square_size.fdiv(2),
-          board_top  + y.add(1) * square_size + square_size - 20,
-          space.piece # text of label, either "x" or "o"
+    for y in 0..grid.height
+      outputs.lines << horizontal_line(y)
+      outputs.lines << early_exit_horizontal_line(y)
     end
+  end
 
-    # Uses a label to output whether x or o won, or if a draw occurred.
-    # If the game is ongoing, a label shows whose turn it currently is.
-    outputs.labels << if state.x_won
-                        label grid.w_half, grid.top - 80, "x won" # the '-80' positions the label 80 pixels lower than top
-                      elsif state.o_won
-                        label grid.w_half, grid.top - 80, "o won" # grid.w_half positions the label in the center horizontally
-                      elsif state.draw
-                        label grid.w_half, grid.top - 80, "a draw"
-                      else # if no one won and the game is ongoing
-                        label grid.w_half, grid.top - 80, "turn: #{state.current_turn}"
-                      end
+  # Easy way to draw vertical lines given an index
+  def vertical_line column
+    scale_up([column, 0, column, grid.height])
   end
 
-  # Calls the methods responsible for handling user input and determining the winner.
-  # Does nothing unless the mouse is clicked.
-  def input_board
-    return unless inputs.mouse.click
-    input_place_piece
-    input_restart_game
-    determine_winner
+  # Easy way to draw horizontal lines given an index
+  def horizontal_line row
+    scale_up([0, row, grid.width, row])
   end
 
-  # Handles user input for placing pieces on the board.
-  def input_place_piece
-    return if state.game_over
+  # Easy way to draw vertical lines given an index
+  def early_exit_vertical_line column
+    scale_up([column + grid.width + 1, 0, column + grid.width + 1, grid.height])
+  end
 
-    # Checks to find the space that the mouse was clicked inside of, and makes sure the space does not already
-    # have a piece in it.
-    __, __, space = all_spaces.find do |__, __, space|
-      inputs.mouse.click.point.inside_rect?(space.border) && !space.piece
+  # Easy way to draw horizontal lines given an index
+  def early_exit_horizontal_line row
+    scale_up([grid.width + 1, row, grid.width + grid.width + 1, row])
+  end
+
+  # Draws the walls on both grids
+  def render_walls
+    state.walls.each_key do |wall|
+      outputs.solids << [scale_up(wall), wall_color]
+      outputs.solids << [early_exit_scale_up(wall), wall_color]
     end
+  end
 
-    # The piece that goes into the space belongs to the player whose turn it currently is.
-    return unless space
-    space.piece = state.current_turn
+  # Renders the star on both grids
+  def render_star
+    outputs.sprites << [scale_up(state.star), 'star.png']
+    outputs.sprites << [early_exit_scale_up(state.star), 'star.png']
+  end
 
-    # This ternary operator statement allows us to change the current player's turn.
-    # If it is currently x's turn, it becomes o's turn. If it is not x's turn, it become's x's turn.
-    state.current_turn = state.current_turn == :x ? :o : :x
+  # Renders the target on both grids
+  def render_target
+    outputs.sprites << [scale_up(state.target), 'target.png']
+    outputs.sprites << [early_exit_scale_up(state.target), 'target.png']
   end
 
-  # Resets the game.
-  def input_restart_game
-    return unless state.game_over
-    gtk.reset
+  # Labels the grids
+  def render_labels
+    outputs.labels << [200, 625, "Without early exit"]
+    outputs.labels << [875, 625, "With early exit"]
   end
 
-  # Checks if x or o won the game.
-  # If neither player wins and all nine squares are filled, a draw happens.
-  # Once a player is chosen as the winner or a draw happens, the game is over.
-  def determine_winner
-    state.x_won = won? :x # evaluates to either true or false (boolean values)
-    state.o_won = won? :o
-    state.draw = true if filled_spaces.length == 9 && !state.x_won && !state.o_won
-    state.game_over = state.x_won || state.o_won || state.draw
+  # Renders the path based off of the state.path hash
+  def render_path
+    # If the star and target are disconnected there will only be one path
+    # The path should not render in that case
+    unless state.path.size == 1
+      state.path.each_key do | cell |
+        # Renders path on both grids
+        outputs.solids << [scale_up(cell), path_color]
+        outputs.solids << [early_exit_scale_up(cell), path_color]
+      end
+    end
   end
 
-  # Determines if a player won by checking if there is a horizontal match or vertical match.
-  # Horizontal_match and vertical_match have boolean values. If either is true, the game has been won.
-  def won? piece
-    # performs action on all space combinations
-    won = [[-1, 0, 1]].product([-1, 0, 1]).map do |xs, y|
+  # Calculates the path from the target to the star after the search is over
+  # Relies on the came_from hash
+  # Fills the state.path hash, which is later rendered on screen
+  def calc_path
+    endpoint = state.target
+    while endpoint
+      state.path[endpoint] = true
+      endpoint = state.came_from[endpoint]
+    end
+  end
 
-      # Checks if the 3 grid spaces with the same y value (or same row) and
-      # x values that are next to each other have pieces that belong to the same player.
-      # Remember, the value of piece is equal to the current turn (which is the player).
-      horizontal_match = state.spaces[xs[0]][y].piece == piece &&
-                         state.spaces[xs[1]][y].piece == piece &&
-                         state.spaces[xs[2]][y].piece == piece
+  # Representation of how far away visited cells are from the star
+  # Replaces the render_visited method
+  # Visually demonstrates the effectiveness of early exit for pathfinding
+  def render_heat_map
+    state.visited.each_key do | visited_cell |
+      distance = (state.star.x - visited_cell.x).abs + (state.star.y - visited_cell.y).abs
+      max_distance = grid.width + grid.height
+      alpha = 255.to_i * distance.to_i / max_distance.to_i
+      outputs.solids << [scale_up(visited_cell), red, alpha]
+      # outputs.solids << [early_exit_scale_up(visited_cell), red, alpha]
+    end
 
-      # Checks if the 3 grid spaces with the same x value (or same column) and
-      # y values that are next to each other have pieces that belong to the same player.
-      # The && represents an "and" statement: if even one part of the statement is false,
-      # the entire statement evaluates to false.
-      vertical_match = state.spaces[y][xs[0]].piece == piece &&
-                       state.spaces[y][xs[1]].piece == piece &&
-                       state.spaces[y][xs[2]].piece == piece
+    state.early_exit_visited.each_key do | visited_cell |
+      distance = (state.star.x - visited_cell.x).abs + (state.star.y - visited_cell.y).abs
+      max_distance = grid.width + grid.height
+      alpha = 255.to_i * distance.to_i / max_distance.to_i
+      outputs.solids << [early_exit_scale_up(visited_cell), red, alpha]
+    end
+  end
 
-      horizontal_match || vertical_match # if either is true, true is returned
+  # Translates the given cell grid.width + 1 to the right and then scales up
+  # Used to draw cells for the second grid
+  # This method does not work for lines,
+  # so separate methods exist for the grid lines
+  def early_exit_scale_up(cell)
+    cell_clone = cell.clone
+    cell_clone.x += grid.width + 1
+    scale_up(cell_clone)
+  end
+
+  # In code, the cells are represented as 1x1 rectangles
+  # When drawn, the cells are larger than 1x1 rectangles
+  # This method is used to scale up cells, and lines
+  # Objects are scaled up according to the grid.cell_size variable
+  # This allows for easy customization of the visual scale of the grid
+  def scale_up(cell)
+    # Prevents the original value of cell from being edited
+    cell = cell.clone
+
+    # If cell is just an x and y coordinate
+    if cell.size == 2
+      # Add a width and height of 1
+      cell << 1
+      cell << 1
     end
 
-    # Sees if there is a diagonal match, starting from the bottom left and ending at the top right.
-    # Is added to won regardless of whether the statement is true or false.
-    won << (state.spaces[-1][-1].piece == piece && # bottom left
-            state.spaces[ 0][ 0].piece == piece && # center
-            state.spaces[ 1][ 1].piece == piece)   # top right
+    # Scale all the values up
+    cell.map! { |value| value * grid.cell_size }
 
-    # Sees if there is a diagonal match, starting at the bottom right and ending at the top left
-    # and is added to won.
-    won << (state.spaces[ 1][-1].piece == piece && # bottom right
-            state.spaces[ 0][ 0].piece == piece && # center
-            state.spaces[-1][ 1].piece == piece)   # top left
+    # Returns the scaled up cell
+    cell
+  end
 
-    # Any false statements (meaning false diagonal matches) are rejected from won
-    won.reject_false.any?
+  # This method processes user input every tick
+  # Any method with "1" is related to the first grid
+  # Any method with "2" is related to the second grid
+  def input
+    # The program has to remember that the user is dragging an object
+    # even when the mouse is no longer over that object
+    # So detecting input and processing input is separate
+    detect_input
+    process_input
   end
 
-  # Defines filled spaces on the board by rejecting all spaces that do not have game pieces in them.
-  # The ! before a statement means "not". For example, we are rejecting any space combinations that do
-  # NOT have pieces in them.
-  def filled_spaces
-    state.space_combinations
-      .reject { |x, y| !state.spaces[x][y].piece } # reject spaces with no pieces in them
-      .map do |x, y|
-        if block_given?
-          yield x, y, state.spaces[x][y]
-        else
-          [x, y, state.spaces[x][y]] # sets definition of space
-        end
+  # Determines what the user is editing and stores the value
+  # Storing the value allows the user to continue the same edit as long as the
+  # mouse left click is held
+  def detect_input
+    # When the mouse is up, nothing is being edited
+    if inputs.mouse.up
+      state.current_input = :none
+    # When the star in the no second grid is clicked
+    elsif star_clicked?
+      state.current_input = :star
+    # When the star in the second grid is clicked
+    elsif star2_clicked?
+      state.current_input = :star2
+    # When the target in the no second grid is clicked
+    elsif target_clicked?
+      state.current_input = :target
+    # When the target in the second grid is clicked
+    elsif target2_clicked?
+      state.current_input = :target2
+    # When a wall in the first grid is clicked
+    elsif wall_clicked?
+      state.current_input = :remove_wall
+    # When a wall in the second grid is clicked
+    elsif wall2_clicked?
+      state.current_input = :remove_wall2
+    # When the first grid is clicked
+    elsif grid_clicked?
+      state.current_input = :add_wall
+    # When the second grid is clicked
+    elsif grid2_clicked?
+      state.current_input = :add_wall2
+    end
+  end
+
+  # Processes click and drag based on what the user is currently dragging
+  def process_input
+    if state.current_input == :star
+      input_star
+    elsif state.current_input == :star2
+      input_star2
+    elsif state.current_input == :target
+      input_target
+    elsif state.current_input == :target2
+      input_target2
+    elsif state.current_input == :remove_wall
+      input_remove_wall
+    elsif state.current_input == :remove_wall2
+      input_remove_wall2
+    elsif state.current_input == :add_wall
+      input_add_wall
+    elsif state.current_input == :add_wall2
+      input_add_wall2
+    end
+  end
+
+  # Moves the star to the cell closest to the mouse in the first grid
+  # Only resets the search if the star changes position
+  # Called whenever the user is editing the star (puts mouse down on star)
+  def input_star
+    old_star = state.star.clone
+    state.star = cell_closest_to_mouse
+    unless old_star == state.star
+      reset_search
+    end
+  end
+
+  # Moves the star to the cell closest to the mouse in the second grid
+  # Only resets the search if the star changes position
+  # Called whenever the user is editing the star (puts mouse down on star)
+  def input_star2
+    old_star = state.star.clone
+    state.star = cell_closest_to_mouse2
+    unless old_star == state.star
+      reset_search
+    end
+  end
+
+  # Moves the target to the grid closest to the mouse in the first grid
+  # Only reset_searchs the search if the target changes position
+  # Called whenever the user is editing the target (puts mouse down on target)
+  def input_target
+    old_target = state.target.clone
+    state.target = cell_closest_to_mouse
+    unless old_target == state.target
+      reset_search
+    end
+  end
+
+  # Moves the target to the cell closest to the mouse in the second grid
+  # Only reset_searchs the search if the target changes position
+  # Called whenever the user is editing the target (puts mouse down on target)
+  def input_target2
+    old_target = state.target.clone
+    state.target = cell_closest_to_mouse2
+    unless old_target == state.target
+      reset_search
+    end
+  end
+
+  # Removes walls in the first grid that are under the cursor
+  def input_remove_wall
+    # The mouse needs to be inside the grid, because we only want to remove walls
+    # the cursor is directly over
+    # Recalculations should only occur when a wall is actually deleted
+    if mouse_inside_grid?
+      if state.walls.has_key?(cell_closest_to_mouse)
+        state.walls.delete(cell_closest_to_mouse)
+        reset_search
+      end
     end
   end
 
-  # Defines all spaces on the board.
-  def all_spaces
-    if !block_given?
-      state.space_combinations.map do |x, y|
-        [x, y, state.spaces[x][y]] # sets definition of space
+  # Removes walls in the second grid that are under the cursor
+  def input_remove_wall2
+    # The mouse needs to be inside the grid, because we only want to remove walls
+    # the cursor is directly over
+    # Recalculations should only occur when a wall is actually deleted
+    if mouse_inside_grid2?
+      if state.walls.has_key?(cell_closest_to_mouse2)
+        state.walls.delete(cell_closest_to_mouse2)
+        reset_search
       end
-    else # if a block is given (block_given? is true)
-      state.space_combinations.map do |x, y|
-        yield x, y, state.spaces[x][y] # yield if a block is given
+    end
+  end
+
+  # Adds a wall in the first grid in the cell the mouse is over
+  def input_add_wall
+    if mouse_inside_grid?
+      unless state.walls.has_key?(cell_closest_to_mouse)
+        state.walls[cell_closest_to_mouse] = true
+        reset_search
       end
     end
   end
 
-  # Sets values for a label, such as the position, value, size, alignment, and color.
-  def label x, y, value
-    [x, y + 10, value, 20, 1, 0, 0, 0]
+
+  # Adds a wall in the second grid in the cell the mouse is over
+  def input_add_wall2
+    if mouse_inside_grid2?
+      unless state.walls.has_key?(cell_closest_to_mouse2)
+        state.walls[cell_closest_to_mouse2] = true
+        reset_search
+      end
+    end
   end
-end
 
-$tic_tac_toe = TicTacToe.new
+  # Whenever the user edits the grid,
+  # The search has to be reset_searchd upto the current step
+  # with the current grid as the initial state of the grid
+  def reset_search
+    # Reset_Searchs the search
+    state.frontier  = []
+    state.visited   = {}
+    state.early_exit_visited   = {}
+    state.came_from = {}
+    state.path      = {}
+  end
+
+  # Moves the search forward one step
+  def step
+    # The setup to the search
+    # Runs once when there are no visited cells
+    if state.visited.empty?
+      state.visited[state.star] = true
+      state.early_exit_visited[state.star] = true
+      state.frontier << state.star
+      state.came_from[state.star] = nil
+    end
+
+    # A step in the search
+    unless state.frontier.empty?
+      # Takes the next frontier cell
+      new_frontier = state.frontier.shift
+      # For each of its neighbors
+      adjacent_neighbors(new_frontier).each do |neighbor|
+        # That have not been visited and are not walls
+        unless state.visited.has_key?(neighbor) || state.walls.has_key?(neighbor)
+          # Add them to the frontier and mark them as visited in the first grid
+          state.visited[neighbor] = true
+          # Unless the target has been visited
+          unless state.visited.has_key?(state.target)
+            # Mark the neighbor as visited in the second grid as well
+            state.early_exit_visited[neighbor] = true
+          end
 
-def tick args
-  $tic_tac_toe._       = args
-  $tic_tac_toe.state   = args.state
-  $tic_tac_toe.outputs = args.outputs
-  $tic_tac_toe.inputs  = args.inputs
-  $tic_tac_toe.grid    = args.grid
-  $tic_tac_toe.gtk     = args.gtk
-  $tic_tac_toe.tick
-  tick_instructions args, "Sample app shows how to work with mouse clicks."
-end
+          # Add the neighbor to the frontier and remember which cell it came from
+          state.frontier << neighbor
+          state.came_from[neighbor] = new_frontier
+        end
+      end
+    end
+  end
 
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
+
+  # Returns a list of adjacent cells
+  # Used to determine what the next cells to be added to the frontier are
+  def adjacent_neighbors(cell)
+    neighbors = []
+
+    # Gets all the valid neighbors into the array
+    # From southern neighbor, clockwise
+    neighbors << [cell.x, cell.y - 1] unless cell.y == 0
+    neighbors << [cell.x - 1, cell.y] unless cell.x == 0
+    neighbors << [cell.x, cell.y + 1] unless cell.y == grid.height - 1
+    neighbors << [cell.x + 1, cell.y] unless cell.x == grid.width - 1
+
+    # Sorts the neighbors so the rendered path is a zigzag path
+    # Cells in a diagonal direction are given priority
+    # Comment this line to see the difference
+    neighbors = neighbors.sort_by { |neighbor_x, neighbor_y|  proximity_to_star(neighbor_x, neighbor_y) }
+
+    neighbors
   end
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
-end
+  # Finds the vertical and horizontal distance of a cell from the star
+  # and returns the larger value
+  # This method is used to have a zigzag pattern in the rendered path
+  # A cell that is [5, 5] from the star,
+  # is explored before over a cell that is [0, 7] away.
+  # So, if possible, the search tries to go diagonal (zigzag) first
+  def proximity_to_star(x, y)
+    distance_x = (state.star.x - x).abs
+    distance_y = (state.star.y - y).abs
 
-

-Mouse - Mouse Move - main.rb
-# ./samples/05_mouse/02_mouse_move/app/main.rb
-=begin
+    if distance_x > distance_y
+      return distance_x
+    else
+      return distance_y
+    end
+  end
 
- Reminders:
+  # When the user grabs the star and puts their cursor to the far right
+  # and moves up and down, the star is supposed to move along the grid as well
+  # Finding the cell closest to the mouse helps with this
+  def cell_closest_to_mouse
+    # Closest cell to the mouse in the first grid
+    x = (inputs.mouse.point.x / grid.cell_size).to_i
+    y = (inputs.mouse.point.y / grid.cell_size).to_i
+    # Bound x and y to the grid
+    x = grid.width - 1 if x > grid.width - 1
+    y = grid.height - 1 if y > grid.height - 1
+    # Return closest cell
+    [x, y]
+  end
 
- - num1.greater(num2): Returns the greater value.
-   For example, if we have the command
-   puts 4.greater(3)
-   the number 4 would be printed to the console since it has a greater value than 3.
-   Similar to lesser, which returns the lesser value.
+  # When the user grabs the star and puts their cursor to the far right
+  # and moves up and down, the star is supposed to move along the grid as well
+  # Finding the cell closest to the mouse in the second grid helps with this
+  def cell_closest_to_mouse2
+    # Closest cell grid to the mouse in the second
+    x = (inputs.mouse.point.x / grid.cell_size).to_i
+    y = (inputs.mouse.point.y / grid.cell_size).to_i
+    # Translate the cell to the first grid
+    x -= grid.width + 1
+    # Bound x and y to the first grid
+    x = grid.width - 1 if x > grid.width - 1
+    y = grid.height - 1 if y > grid.height - 1
+    # Return closest cell
+    [x, y]
+  end
 
- - find_all: Finds all elements of a collection that meet certain requirements.
-   For example, in this sample app, we're using find_all to find all zombies that have intersected
-   or hit the player's sprite since these zombies have been killed.
+  # Signal that the user is going to be moving the star from the first grid
+  def star_clicked?
+    inputs.mouse.down && inputs.mouse.point.inside_rect?(scale_up(state.star))
+  end
 
- - args.inputs.keyboard.key_down.KEY: Determines if a key is being held or pressed.
-   Stores the frame the "down" event occurred.
-   For more information about the keyboard, go to mygame/documentation/06-keyboard.md.
+  # Signal that the user is going to be moving the star from the second grid
+  def star2_clicked?
+    inputs.mouse.down && inputs.mouse.point.inside_rect?(early_exit_scale_up(state.star))
+  end
 
- - args.outputs.sprites: An array. The values generate a sprite.
-   The parameters are [X, Y, WIDTH, HEIGHT, PATH, ANGLE, ALPHA, RED, GREEN, BLUE]
-   For more information about sprites, go to mygame/documentation/05-sprites.md.
+  # Signal that the user is going to be moving the target from the first grid
+  def target_clicked?
+    inputs.mouse.down && inputs.mouse.point.inside_rect?(scale_up(state.target))
+  end
 
- - args.state.new_entity: Used when we want to create a new object, like a sprite or button.
-   When we want to create a new object, we can declare it as a new entity and then define
-   its properties. (Remember, you can use state to define ANY property and it will
-   be retained across frames.)
+  # Signal that the user is going to be moving the target from the second grid
+  def target2_clicked?
+    inputs.mouse.down && inputs.mouse.point.inside_rect?(early_exit_scale_up(state.target))
+  end
 
- - String interpolation: Uses #{} syntax; everything between the #{ and the } is evaluated
-   as Ruby code, and the placeholder is replaced with its corresponding value or result.
+  # Signal that the user is going to be removing walls from the first grid
+  def wall_clicked?
+    inputs.mouse.down && mouse_inside_wall?
+  end
 
- - map: Ruby method used to transform data; used in arrays, hashes, and collections.
-   Can be used to perform an action on every element of a collection, such as multiplying
-   each element by 2 or declaring every element as a new entity.
+  # Signal that the user is going to be removing walls from the second grid
+  def wall2_clicked?
+    inputs.mouse.down && mouse_inside_wall2?
+  end
 
- - sample: Chooses a random element from the array.
+  # Signal that the user is going to be adding walls from the first grid
+  def grid_clicked?
+    inputs.mouse.down && mouse_inside_grid?
+  end
 
- - reject: Removes elements that meet certain requirements.
-   In this sample app, we're removing/rejecting zombies that reach the center of the screen. We're also
-   rejecting zombies that were killed more than 30 frames ago.
+  # Signal that the user is going to be adding walls from the second grid
+  def grid2_clicked?
+    inputs.mouse.down && mouse_inside_grid2?
+  end
 
-=end
+  # Returns whether the mouse is inside of a wall in the first grid
+  # Part of the condition that checks whether the user is removing a wall
+  def mouse_inside_wall?
+    state.walls.each_key do | wall |
+      return true if inputs.mouse.point.inside_rect?(scale_up(wall))
+    end
 
-# This sample app allows users to move around the screen in order to kill zombies. Zombies appear from every direction so the goal
-# is to kill the zombies as fast as possible!
+    false
+  end
 
-class ProtectThePuppiesFromTheZombies
-  attr_accessor :grid, :inputs, :state, :outputs
+  # Returns whether the mouse is inside of a wall in the second grid
+  # Part of the condition that checks whether the user is removing a wall
+  def mouse_inside_wall2?
+    state.walls.each_key do | wall |
+      return true if inputs.mouse.point.inside_rect?(early_exit_scale_up(wall))
+    end
 
-  # Calls the methods necessary for the game to run properly.
-  def tick
-    defaults
-    render
-    calc
-    input
+    false
   end
 
-  # Sets default values for the zombies and for the player.
-  # Initialization happens only in the first frame.
-  def defaults
-    state.flash_at               ||= 0
-    state.zombie_min_spawn_rate  ||= 60
-    state.zombie_spawn_countdown ||= random_spawn_countdown state.zombie_min_spawn_rate
-    state.zombies                ||= []
-    state.killed_zombies         ||= []
+  # Returns whether the mouse is inside of the first grid
+  # Part of the condition that checks whether the user is adding a wall
+  def mouse_inside_grid?
+    inputs.mouse.point.inside_rect?(scale_up(grid.rect))
+  end
 
-    # Declares player as a new entity and sets its properties.
-    # The player begins the game in the center of the screen, not moving in any direction.
-    state.player ||= state.new_entity(:player, { x: 640,
-                                               y: 360,
-                                               attack_angle: 0,
-                                               dx: 0,
-                                               dy: 0 })
+  # Returns whether the mouse is inside of the second grid
+  # Part of the condition that checks whether the user is adding a wall
+  def mouse_inside_grid2?
+    inputs.mouse.point.inside_rect?(early_exit_scale_up(grid.rect))
   end
 
-  # Outputs a gray background.
-  # Calls the methods needed to output the player, zombies, etc onto the screen.
-  def render
-    outputs.solids << [grid.rect, 100, 100, 100]
-    render_zombies
-    render_killed_zombies
-    render_player
-    render_flash
+  # These methods provide handy aliases to colors
+
+  # Light brown
+  def unvisited_color
+    [221, 212, 213]
   end
 
-  # Outputs the zombies on the screen and sets values for the sprites, such as the position, width, height, and animation.
-  def render_zombies
-    outputs.sprites << state.zombies.map do |z| # performs action on all zombies in the collection
-      z.sprite = [z.x, z.y, 4 * 3, 8 * 3, animation_sprite(z)].sprite # sets definition for sprite, calls animation_sprite method
-      z.sprite
-    end
+  # Camo Green
+  def wall_color
+    [134, 134, 120]
   end
 
-  # Outputs sprites of killed zombies, and displays a slash image to show that a zombie has been killed.
-  def render_killed_zombies
-    outputs.sprites << state.killed_zombies.map do |z| # performs action on all killed zombies in collection
-      z.sprite = [z.x,
-                  z.y,
-                  4 * 3,
-                  8 * 3,
-                  animation_sprite(z, z.death_at), # calls animation_sprite method
-                  0, # angle
-                  255 * z.death_at.ease(30, :flip)].sprite # transparency of a zombie changes when they die
-                  # change the value of 30 and see what happens when a zombie is killed
+  # Pastel White
+  def path_color
+    [231, 230, 228]
+  end
 
-      # Sets values to output the slash over the zombie's sprite when a zombie is killed.
-      # The slash is tilted 45 degrees from the angle of the player's attack.
-      # Change the 3 inside scale_rect to 30 and the slash will be HUGE! Scale_rect positions
-      # the slash over the killed zombie's sprite.
-      [z.sprite, [z.sprite.rect, 'sprites/slash.png', 45 + state.player.attack_angle_on_click, z.sprite.a].scale_rect(3, 0.5, 0.5)]
-    end
+  def red
+    [255, 0, 0]
+  end
+
+  # Makes code more concise
+  def grid
+    state.grid
+  end
+end
+
+# Method that is called by DragonRuby periodically
+# Used for updating animations and calculations
+def tick args
+
+  # Pressing r will reset the application
+  if args.inputs.keyboard.key_down.r
+    args.gtk.reset
+    reset
+    return
+  end
+
+  # Every tick, new args are passed, and the Breadth First Search tick is called
+  $early_exit_breadth_first_search ||= EarlyExitBreadthFirstSearch.new(args)
+  $early_exit_breadth_first_search.args = args
+  $early_exit_breadth_first_search.tick
+end
+
+
+def reset
+  $early_exit_breadth_first_search = nil
+end
+
+
+Path Finding Algorithms - Dijkstra - main.rb
+# ./samples/13_path_finding_algorithms/05_dijkstra/app/main.rb
+# Demonstrates how Dijkstra's Algorithm allows movement costs to be considered
+
+# Inspired by https://www.redblobgames.com/pathfinding/a-star/introduction.html
+
+# The first grid is a breadth first search with an early exit.
+# It shows a heat map of all the cells that were visited by the search and their relative distance.
+
+# The second grid is an implementation of Dijkstra's algorithm.
+# Light green cells have 5 times the movement cost of regular cells.
+# The heat map will darken based on movement cost.
+
+# Dark green cells are walls, and the search cannot go through them.
+class Movement_Costs
+  attr_gtk
+
+  # This method is called every frame/tick
+  # Every tick, the current state of the search is rendered on the screen,
+  # User input is processed, and
+  # The next step in the search is calculated
+  def tick
+    defaults
+    render
+    input
+    calc
   end
 
-  # Outputs the player sprite using the images in the sprites folder.
-  def render_player
-    state.player_sprite = [state.player.x,
-                           state.player.y,
-                          4 * 3,
-                          8 * 3, "sprites/player-#{animation_index(state.player.created_at_elapsed)}.png"] # string interpolation
-    outputs.sprites << state.player_sprite
+  def defaults
+    # Variables to edit the size and appearance of the grid
+    # Freely customizable to user's liking
+    grid.width     ||= 10
+    grid.height    ||= 10
+    grid.cell_size ||= 60
+    grid.rect      ||= [0, 0, grid.width, grid.height]
+
+    # The location of the star and walls of the grid
+    # They can be modified to have a different initial grid
+    # Walls are stored in a hash for quick look up when doing the search
+    state.star   ||= [1, 5]
+    state.target ||= [8, 4]
+    state.walls  ||= {[1, 1] => true, [2, 1] => true, [3, 1] => true, [1, 2] => true, [2, 2] => true, [3, 2] => true}
+    state.hills  ||= {
+      [4, 1] => true,
+      [5, 1] => true,
+      [4, 2] => true,
+      [5, 2] => true,
+      [6, 2] => true,
+      [4, 3] => true,
+      [5, 3] => true,
+      [6, 3] => true,
+      [3, 4] => true,
+      [4, 4] => true,
+      [5, 4] => true,
+      [6, 4] => true,
+      [7, 4] => true,
+      [3, 5] => true,
+      [4, 5] => true,
+      [5, 5] => true,
+      [6, 5] => true,
+      [7, 5] => true,
+      [4, 6] => true,
+      [5, 6] => true,
+      [6, 6] => true,
+      [7, 6] => true,
+      [4, 7] => true,
+      [5, 7] => true,
+      [6, 7] => true,
+      [4, 8] => true,
+      [5, 8] => true,
+    }
 
-    # Outputs a small red square that previews the angles that the player can attack in.
-    # It can be moved in a perfect circle around the player to show possible movements.
-    # Change the 60 in the parenthesis and see what happens to the movement of the red square.
-    outputs.solids <<  [state.player.x + state.player.attack_angle.vector_x(60),
-                        state.player.y + state.player.attack_angle.vector_y(60),
-                        3, 3, 255, 0, 0]
+    # What the user is currently editing on the grid
+    # We store this value, because we want to remember the value even when
+    # the user's cursor is no longer over what they're interacting with, but
+    # they are still clicking down on the mouse.
+    state.user_input ||= :none
+
+    # Values that are used for the breadth first search
+    # Keeping track of what cells were visited prevents counting cells multiple times
+    breadth_first_search.visited    ||= {}
+    # The cells from which the breadth first search will expand
+    breadth_first_search.frontier   ||= []
+    # Keeps track of which cell all cells were searched from
+    # Used to recreate the path from the target to the star
+    breadth_first_search.came_from  ||= {}
+
+    # Keeps track of the movement cost so far to be at a cell
+    # Allows the costs of new cells to be quickly calculated
+    # Also doubles as a way to check if cells have already been visited
+    dijkstra_search.cost_so_far ||= {}
+    # The cells from which the Dijkstra search will expand
+    dijkstra_search.frontier    ||= []
+    # Keeps track of which cell all cells were searched from
+    # Used to recreate the path from the target to the star
+    dijkstra_search.came_from   ||= {}
+  end
+
+  # Draws everything onto the screen
+  def render
+    render_background
+
+    render_heat_maps
+
+    render_star
+    render_target
+    render_hills
+    render_walls
+
+    render_paths
   end
+  # The methods below subdivide the task of drawing everything to the screen
 
-  # Renders flash as a solid. The screen turns white for 10 frames when a zombie is killed.
-  def render_flash
-    return if state.flash_at.elapsed_time > 10 # return if more than 10 frames have passed since flash.
-    # Transparency gradually changes (or eases) during the 10 frames of flash.
-    outputs.primitives << [grid.rect, 255, 255, 255, 255 * state.flash_at.ease(10, :flip)].solid
+  # Draws what the grid looks like with nothing on it
+  def render_background
+    render_unvisited
+    render_grid_lines
+    render_labels
   end
 
-  # Calls all methods necessary for performing calculations.
-  def calc
-    calc_spawn_zombie
-    calc_move_zombies
-    calc_player
-    calc_kill_zombie
+  # Draws two rectangles the size of the grid in the default cell color
+  # Used as part of the background
+  def render_unvisited
+    outputs.solids << [scale_up(grid.rect), unvisited_color]
+    outputs.solids << [move_and_scale_up(grid.rect), unvisited_color]
   end
 
-  # Decreases the zombie spawn countdown by 1 if it has a value greater than 0.
-  def calc_spawn_zombie
-    if state.zombie_spawn_countdown > 0
-      state.zombie_spawn_countdown -= 1
-      return
+  # Draws grid lines to show the division of the grid into cells
+  def render_grid_lines
+    for x in 0..grid.width
+      outputs.lines << vertical_line(x)
+      outputs.lines << shifted_vertical_line(x)
     end
 
-    # New zombies are created, positioned on the screen, and added to the zombies collection.
-    state.zombies << state.new_entity(:zombie) do |z| # each zombie is declared a new entity
-      if rand > 0.5
-        z.x = grid.rect.w.randomize(:ratio) # random x position on screen (within grid scope)
-        z.y = [-10, 730].sample # y position is set to either -10 or 730 (randomly chosen)
-        # the possible values exceed the screen's scope so zombies appear to be coming from far away
-      else
-        z.x = [-10, 1290].sample # x position is set to either -10 or 1290 (randomly chosen)
-        z.y = grid.rect.w.randomize(:ratio) # random y position on screen
-      end
+    for y in 0..grid.height
+      outputs.lines << horizontal_line(y)
+      outputs.lines << shifted_horizontal_line(y)
     end
+  end
 
-    # Calls random_spawn_countdown method (determines how fast new zombies appear)
-    state.zombie_spawn_countdown = random_spawn_countdown state.zombie_min_spawn_rate
-    state.zombie_min_spawn_rate -= 1
-    # set to either the current zombie_min_spawn_rate or 0, depending on which value is greater
-    state.zombie_min_spawn_rate  = state.zombie_min_spawn_rate.greater(0)
+  # Easy way to draw vertical lines given an index for the first grid
+  def vertical_line column
+    scale_up([column, 0, column, grid.height])
   end
 
-  # Moves all zombies towards the center of the screen.
-  # All zombies that reach the center (640, 360) are rejected from the zombies collection and disappear.
-  def calc_move_zombies
-    state.zombies.each do |z| # for each zombie in the collection
-      z.y = z.y.towards(360, 0.1) # move the zombie towards the center (640, 360) at a rate of 0.1
-      z.x = z.x.towards(640, 0.1) # change 0.1 to 1.1 and see how much faster the zombies move to the center
-    end
-    state.zombies = state.zombies.reject { |z| z.y == 360 && z.x == 640 } # remove zombies that are in center
+  # Easy way to draw horizontal lines given an index for the second grid
+  def horizontal_line row
+    scale_up([0, row, grid.width, row])
   end
 
-  # Calculates the position and movement of the player on the screen.
-  def calc_player
-    state.player.x += state.player.dx # changes x based on dx (change in x)
-    state.player.y += state.player.dy # changes y based on dy (change in y)
+  # Easy way to draw vertical lines given an index for the first grid
+  def shifted_vertical_line column
+    scale_up([column + grid.width + 1, 0, column + grid.width + 1, grid.height])
+  end
 
-    state.player.dx *= 0.9 # scales dx down
-    state.player.dy *= 0.9 # scales dy down
+  # Easy way to draw horizontal lines given an index for the second grid
+  def shifted_horizontal_line row
+    scale_up([grid.width + 1, row, grid.width + grid.width + 1, row])
+  end
 
-    # Compares player's x to 1280 to find lesser value, then compares result to 0 to find greater value.
-    # This ensures that the player remains within the screen's scope.
-    state.player.x = state.player.x.lesser(1280).greater(0)
-    state.player.y = state.player.y.lesser(720).greater(0) # same with player's y
+  # Labels the grids
+  def render_labels
+    outputs.labels << [175, 650, "Number of steps", 3]
+    outputs.labels << [925, 650, "Distance", 3]
   end
 
-  # Finds all zombies that intersect with the player's sprite. These zombies are removed from the zombies collection
-  # and added to the killed_zombies collection since any zombie that intersects with the player is killed.
-  def calc_kill_zombie
+  def render_paths
+    render_breadth_first_search_path
+    render_dijkstra_path
+  end
 
-    # Find all zombies that intersect with the player. They are considered killed.
-    killed_this_frame = state.zombies.find_all { |z| z.sprite.intersect_rect? state.player_sprite }
-    state.zombies = state.zombies - killed_this_frame # remove newly killed zombies from zombies collection
-    state.killed_zombies += killed_this_frame # add newly killed zombies to killed zombies
+  def render_heat_maps
+    render_breadth_first_search_heat_map
+    render_dijkstra_heat_map
+  end
 
-    if killed_this_frame.length > 0 # if atleast one zombie was killed in the frame
-      state.flash_at = state.tick_count # flash_at set to the frame when the zombie was killed
-    # Don't forget, the rendered flash lasts for 10 frames after the zombie is killed (look at render_flash method)
-    end
+  # Renders the breadth first search on the first grid
+  def render_breadth_first_search
+  end
 
-    # Sets the tick_count (passage of time) as the value of the death_at variable for each killed zombie.
-    # Death_at stores the frame a zombie was killed.
-    killed_this_frame.each do |z|
-      z.death_at = state.tick_count
+  # This heat map shows the cells explored by the breadth first search and how far they are from the star.
+  def render_breadth_first_search_heat_map
+    # For each cell explored
+    breadth_first_search.visited.each_key do | visited_cell |
+      # Find its distance from the star
+      distance = (state.star.x - visited_cell.x).abs + (state.star.y - visited_cell.y).abs
+      max_distance = grid.width + grid.height
+      # Get it as a percent of the maximum distance and scale to 255 for use as an alpha value
+      alpha = 255.to_i * distance.to_i / max_distance.to_i
+      outputs.solids << [scale_up(visited_cell), red, alpha]
     end
+  end
 
-    # Zombies are rejected from the killed_zombies collection depending on when they were killed.
-    # They are rejected if more than 30 frames have passed since their death.
-    state.killed_zombies = state.killed_zombies.reject { |z| state.tick_count - z.death_at > 30 }
+  def render_breadth_first_search_path
+    # If the search found the target
+    if breadth_first_search.visited.has_key?(state.target)
+      # Start from the target
+      endpoint = state.target
+      # And the cell it came from
+      next_endpoint = breadth_first_search.came_from[endpoint]
+      while endpoint and next_endpoint
+        # Draw a path between these two cells
+        path = get_path_between(endpoint, next_endpoint)
+        outputs.solids << [scale_up(path), path_color]
+        # And get the next pair of cells
+        endpoint = next_endpoint
+        next_endpoint = breadth_first_search.came_from[endpoint]
+        # Continue till there are no more cells
+      end
+    end
   end
 
-  # Uses input from the user to move the player around the screen.
-  def input
+  # Renders the Dijkstra search on the second grid
+  def render_dijkstra
+  end
 
-    # If the "a" key or left key is pressed, the x position of the player decreases.
-    # Otherwise, if the "d" key or right key is pressed, the x position of the player increases.
-    if inputs.keyboard.key_held.a || inputs.keyboard.key_held.left
-      state.player.x -= 5
-    elsif inputs.keyboard.key_held.d || inputs.keyboard.key_held.right
-      state.player.x += 5
+  def render_dijkstra_heat_map
+    dijkstra_search.cost_so_far.each do |visited_cell, cost|
+      max_cost = (grid.width + grid.height) #* 5
+      alpha = 255.to_i * cost.to_i / max_cost.to_i
+      outputs.solids << [move_and_scale_up(visited_cell), red, alpha]
     end
+  end
 
-    # If the "w" or up key is pressed, the y position of the player increases.
-    # Otherwise, if the "s" or down key is pressed, the y position of the player decreases.
-    if inputs.keyboard.key_held.w || inputs.keyboard.key_held.up
-      state.player.y += 5
-    elsif inputs.keyboard.key_held.s || inputs.keyboard.key_held.down
-      state.player.y -= 5
+  def render_dijkstra_path
+    # If the search found the target
+    if dijkstra_search.came_from.has_key?(state.target)
+      # Get the target and the cell it came from
+      endpoint = state.target
+      next_endpoint = dijkstra_search.came_from[endpoint]
+      while endpoint and next_endpoint
+        # Draw a path between them
+        path = get_path_between(endpoint, next_endpoint)
+        outputs.solids << [move_and_scale_up(path), path_color]
+
+        # Shift one cell down the path
+        endpoint = next_endpoint
+        next_endpoint = dijkstra_search.came_from[endpoint]
+
+        # Repeat till the end of the path
+      end
     end
+  end
 
-    # Sets the attack angle so the player can move and attack in the precise direction it wants to go.
-    # If the mouse is moved, the attack angle is changed (based on the player's position and mouse position).
-    # Attack angle also contributes to the position of red square.
-    if inputs.mouse.moved
-      state.player.attack_angle = inputs.mouse.position.angle_from [state.player.x, state.player.y]
+  # Renders the star on both grids
+  def render_star
+    outputs.sprites << [scale_up(state.star), 'star.png']
+    outputs.sprites << [move_and_scale_up(state.star), 'star.png']
+  end
+
+  # Renders the target on both grids
+  def render_target
+    outputs.sprites << [scale_up(state.target), 'target.png']
+    outputs.sprites << [move_and_scale_up(state.target), 'target.png']
+  end
+
+  def render_hills
+    state.hills.each_key do |hill|
+      outputs.solids << [scale_up(hill), hill_color]
+      outputs.solids << [move_and_scale_up(hill), hill_color]
     end
+  end
 
-    if inputs.mouse.click && state.player.dx < 0.5 && state.player.dy < 0.5
-      state.player.attack_angle_on_click = inputs.mouse.position.angle_from [state.player.x, state.player.y]
-      state.player.attack_angle = state.player.attack_angle_on_click # player's attack angle is set
-      state.player.dx = state.player.attack_angle.vector_x(25) # change in player's position
-      state.player.dy = state.player.attack_angle.vector_y(25)
+  # Draws the walls on both grids
+  def render_walls
+    state.walls.each_key do |wall|
+      outputs.solids << [scale_up(wall), wall_color]
+      outputs.solids << [move_and_scale_up(wall), wall_color]
     end
   end
 
-  # Sets the zombie spawn's countdown to a random number.
-  # How fast zombies appear (change the 60 to 6 and too many zombies will appear at once!)
-  def random_spawn_countdown minimum
-    10.randomize(:ratio, :sign).to_i + 60
+  def get_path_between(cell_one, cell_two)
+    path = nil
+    if cell_one.x == cell_two.x
+      if cell_one.y < cell_two.y
+        path = [cell_one.x + 0.3, cell_one.y + 0.3, 0.4, 1.4]
+      else
+        path = [cell_two.x + 0.3, cell_two.y + 0.3, 0.4, 1.4]
+      end
+    else
+      if cell_one.x < cell_two.x
+        path = [cell_one.x + 0.3, cell_one.y + 0.3, 1.4, 0.4]
+      else
+        path = [cell_two.x + 0.3, cell_two.y + 0.3, 1.4, 0.4]
+      end
+    end
+    path
   end
 
-  # Helps to iterate through the images in the sprites folder by setting the animation index.
-  # 3 frames is how long to show an image, and 6 is how many images to flip through.
-  def animation_index at
-    at.idiv(3).mod(6)
+  # Representation of how far away visited cells are from the star
+  # Replaces the render_visited method
+  # Visually demonstrates the effectiveness of early exit for pathfinding
+  def render_breadth_first_search_heat_map
+    breadth_first_search.visited.each_key do | visited_cell |
+      distance = (state.star.x - visited_cell.x).abs + (state.star.y - visited_cell.y).abs
+      max_distance = grid.width + grid.height
+      alpha = 255.to_i * distance.to_i / max_distance.to_i
+      outputs.solids << [scale_up(visited_cell), red, alpha]
+    end
   end
 
-  # Animates the zombies by using the animation index to go through the images in the sprites folder.
-  def animation_sprite zombie, at = nil
-    at ||= zombie.created_at_elapsed # how long it is has been since a zombie was created
-    index = animation_index at
-    "sprites/zombie-#{index}.png" # string interpolation to iterate through images
+  # Translates the given cell grid.width + 1 to the right and then scales up
+  # Used to draw cells for the second grid
+  # This method does not work for lines,
+  # so separate methods exist for the grid lines
+  def move_and_scale_up(cell)
+    cell_clone = cell.clone
+    cell_clone.x += grid.width + 1
+    scale_up(cell_clone)
   end
-end
 
-$protect_the_puppies_from_the_zombies = ProtectThePuppiesFromTheZombies.new
+  # In code, the cells are represented as 1x1 rectangles
+  # When drawn, the cells are larger than 1x1 rectangles
+  # This method is used to scale up cells, and lines
+  # Objects are scaled up according to the grid.cell_size variable
+  # This allows for easy customization of the visual scale of the grid
+  def scale_up(cell)
+    # Prevents the original value of cell from being edited
+    cell = cell.clone
 
-def tick args
-  $protect_the_puppies_from_the_zombies.grid    = args.grid
-  $protect_the_puppies_from_the_zombies.inputs  = args.inputs
-  $protect_the_puppies_from_the_zombies.state    = args.state
-  $protect_the_puppies_from_the_zombies.outputs = args.outputs
-  $protect_the_puppies_from_the_zombies.tick
-  tick_instructions args, "How to get the mouse position and translate it to an x, y position using .vector_x and .vector_y. CLICK to play."
-end
+    # If cell is just an x and y coordinate
+    if cell.size == 2
+      # Add a width and height of 1
+      cell << 1
+      cell << 1
+    end
 
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
+    # Scale all the values up
+    cell.map! { |value| value * grid.cell_size }
+
+    # Returns the scaled up cell
+    cell
   end
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
-end
+  # Handles user input every tick so the grid can be edited
+  # Separate input detection and processing is needed
+  # For example: Adding walls is started by clicking down on a hill,
+  # but the mouse doesn't need to remain over hills to add walls
+  def input
+    # If the mouse was lifted this tick
+    if inputs.mouse.up
+      # Set current input to none
+      state.user_input = :none
+    end
 
-

-Mouse - Mouse Move Paint App - main.rb
-# ./samples/05_mouse/03_mouse_move_paint_app/app/main.rb
-=begin
+    # If the mouse was clicked this tick
+    if inputs.mouse.down
+      # Determine what the user is editing and edit the state.user_input variable
+      determine_input
+    end
 
- APIs listing that haven't been encountered in previous sample apps:
+    # Process user input based on user_input variable and current mouse position
+    process_input
+  end
 
- - Floor: Method that returns an integer number smaller than or equal to the original with no decimal.
+  # Determines what the user is editing and stores the value
+  # This method is called the tick the mouse is clicked
+  # Storing the value allows the user to continue the same edit as long as the
+  # mouse left click is held
+  def determine_input
+    # If the mouse is over the star in the first grid
+    if mouse_over_star?
+      # The user is editing the star from the first grid
+      state.user_input = :star
+    # If the mouse is over the star in the second grid
+    elsif mouse_over_star2?
+      # The user is editing the star from the second grid
+      state.user_input = :star2
+    # If the mouse is over the target in the first grid
+    elsif mouse_over_target?
+      # The user is editing the target from the first grid
+      state.user_input = :target
+    # If the mouse is over the target in the second grid
+    elsif mouse_over_target2?
+      # The user is editing the target from the second grid
+      state.user_input = :target2
+    # If the mouse is over a wall in the first grid
+    elsif mouse_over_wall?
+      # The user is removing a wall from the first grid
+      state.user_input = :remove_wall
+    # If the mouse is over a wall in the second grid
+    elsif mouse_over_wall2?
+      # The user is removing a wall from the second grid
+      state.user_input = :remove_wall2
+    # If the mouse is over a hill in the first grid
+    elsif mouse_over_hill?
+      # The user is adding a wall from the first grid
+      state.user_input = :add_wall
+    # If the mouse is over a hill in the second grid
+    elsif mouse_over_hill2?
+      # The user is adding a wall from the second grid
+      state.user_input = :add_wall2
+    # If the mouse is over the first grid
+    elsif mouse_over_grid?
+      # The user is adding a hill from the first grid
+      state.user_input = :add_hill
+    # If the mouse is over the second grid
+    elsif mouse_over_grid2?
+      # The user is adding a hill from the second grid
+      state.user_input = :add_hill2
+    end
+  end
+
+  # Processes click and drag based on what the user is currently dragging
+  def process_input
+    if state.user_input == :star
+      input_star
+    elsif state.user_input == :star2
+      input_star2
+    elsif state.user_input == :target
+      input_target
+    elsif state.user_input == :target2
+      input_target2
+    elsif state.user_input == :remove_wall
+      input_remove_wall
+    elsif state.user_input == :remove_wall2
+      input_remove_wall2
+    elsif state.user_input == :add_hill
+      input_add_hill
+    elsif state.user_input == :add_hill2
+      input_add_hill2
+    elsif state.user_input == :add_wall
+      input_add_wall
+    elsif state.user_input == :add_wall2
+      input_add_wall2
+    end
+  end
+
+  # Calculates the two searches
+  def calc
+    # If the searches have not started
+    if breadth_first_search.visited.empty?
+      # Calculate the two searches
+      calc_breadth_first
+      calc_dijkstra
+    end
+  end
+
+
+  def calc_breadth_first
+    # Sets up the Breadth First Search
+    breadth_first_search.visited[state.star]   = true
+    breadth_first_search.frontier              << state.star
+    breadth_first_search.came_from[state.star] = nil
+
+    until breadth_first_search.frontier.empty?
+      return if breadth_first_search.visited.has_key?(state.target)
+      # A step in the search
+      # Takes the next frontier cell
+      new_frontier = breadth_first_search.frontier.shift
+      # For each of its neighbors
+      adjacent_neighbors(new_frontier).each do | neighbor |
+        # That have not been visited and are not walls
+        unless breadth_first_search.visited.has_key?(neighbor) || state.walls.has_key?(neighbor)
+          # Add them to the frontier and mark them as visited in the first grid
+          breadth_first_search.visited[neighbor] = true
+          breadth_first_search.frontier << neighbor
+          # Remember which cell the neighbor came from
+          breadth_first_search.came_from[neighbor] = new_frontier
+        end
+      end
+    end
+  end
 
-   For example, if we have a variable, a = 13.7, and we called floor on it, it would look like this...
-   puts a.floor()
-   which would print out 13.
-   (There is also a ceil method, which returns an integer number greater than or equal to the original
-   with no decimal. If we had called ceil on the variable a, the result would have been 14.)
+  # Calculates the Dijkstra Search from the beginning to the end
 
- Reminders:
+  def calc_dijkstra
+    # The initial values for the Dijkstra search
+    dijkstra_search.frontier                << [state.star, 0]
+    dijkstra_search.came_from[state.star]   = nil
+    dijkstra_search.cost_so_far[state.star] = 0
 
- - Hashes: Collection of unique keys and their corresponding values. The value can be found
-   using their keys.
+    # Until their are no more cells to be explored
+    until dijkstra_search.frontier.empty?
+      # Get the next cell to be explored from
+      # We get the first element of the array which is the cell. The second element is the priority.
+      current = dijkstra_search.frontier.shift[0]
 
-   For example, if we have a "numbers" hash that stores numbers in English as the
-   key and numbers in Spanish as the value, we'd have a hash that looks like this...
-   numbers = { "one" => "uno", "two" => "dos", "three" => "tres" }
-   and on it goes.
+      # Stop the search if we found the target
+      return if current == state.target
 
-   Now if we wanted to find the corresponding value of the "one" key, we could say
-   puts numbers["one"]
-   which would print "uno" to the console.
+      # For each of the neighbors
+      adjacent_neighbors(current).each do | neighbor |
+        # Unless this cell is a wall or has already been explored.
+        unless dijkstra_search.came_from.has_key?(neighbor) or state.walls.has_key?(neighbor)
+          # Calculate the movement cost of getting to this cell and memo
+          new_cost = dijkstra_search.cost_so_far[current] + cost(neighbor)
+          dijkstra_search.cost_so_far[neighbor] = new_cost
 
- - args.state.new_entity: Used when we want to create a new object, like a sprite or button.
-   In this sample app, new_entity is used to create a new button that clears the grid.
-   (Remember, you can use state to define ANY property and it will be retained across frames.)
+          # Add this neighbor to the cells too be explored
+          dijkstra_search.frontier << [neighbor, new_cost]
+          dijkstra_search.came_from[neighbor] = current
+        end
+      end
 
- - args.inputs.mouse.click.point.(x|y): The x and y location of the mouse.
+      # Sort the frontier so exploration occurs that have a low cost so far.
+      # My implementation of a priority queue
+      dijkstra_search.frontier = dijkstra_search.frontier.sort_by {|cell, priority| priority}
+    end
+  end
 
- - args.inputs.mouse.click.point.created_at: The frame the mouse click occurred in.
+  def cost(cell)
+    if state.hills.has_key?(cell)
+      return 5
+    else
+      return 1
+    end
+  end
 
- - args.outputs.labels: An array. The values in the array generate a label.
-   The parameters are [X, Y, TEXT, SIZE, ALIGN, RED, GREEN, BLUE, ALPHA, FONT STYLE]
-   For more information about labels, go to mygame/documentation/02-labels.md.
 
- - ARRAY#inside_rect?: Returns true or false depending on if the point is inside the rect.
 
-=end
 
-# This sample app shows an empty grid that the user can paint on.
-# To paint, the user must keep their mouse presssed and drag it around the grid.
-# The "clear" button allows users to clear the grid so they can start over.
+  # Moves the star to the cell closest to the mouse in the first grid
+  # Only resets the search if the star changes position
+  # Called whenever the user is editing the star (puts mouse down on star)
+  def input_star
+    old_star = state.star.clone
+    unless cell_closest_to_mouse == state.target
+      state.star = cell_closest_to_mouse
+    end
+    unless old_star == state.star
+      reset_search
+    end
+  end
 
-class PaintApp
-  attr_accessor :inputs, :state, :outputs, :grid, :args
+  # Moves the star to the cell closest to the mouse in the second grid
+  # Only resets the search if the star changes position
+  # Called whenever the user is editing the star (puts mouse down on star)
+  def input_star2
+    old_star = state.star.clone
+    unless cell_closest_to_mouse2 == state.target
+      state.star = cell_closest_to_mouse2
+    end
+    unless old_star == state.star
+      reset_search
+    end
+  end
 
-  # Runs methods necessary for the game to function properly.
-  def tick
-    print_title
-    add_grid
-    check_click
-    draw_buttons
+  # Moves the target to the grid closest to the mouse in the first grid
+  # Only reset_searchs the search if the target changes position
+  # Called whenever the user is editing the target (puts mouse down on target)
+  def input_target
+    old_target = state.target.clone
+    unless cell_closest_to_mouse == state.star
+      state.target = cell_closest_to_mouse
+    end
+    unless old_target == state.target
+      reset_search
+    end
+  end
+
+  # Moves the target to the cell closest to the mouse in the second grid
+  # Only reset_searchs the search if the target changes position
+  # Called whenever the user is editing the target (puts mouse down on target)
+  def input_target2
+    old_target = state.target.clone
+    unless cell_closest_to_mouse2 == state.star
+      state.target = cell_closest_to_mouse2
+    end
+    unless old_target == state.target
+      reset_search
+    end
+  end
+
+  # Removes walls in the first grid that are under the cursor
+  def input_remove_wall
+    # The mouse needs to be inside the grid, because we only want to remove walls
+    # the cursor is directly over
+    # Recalculations should only occur when a wall is actually deleted
+    if mouse_over_grid?
+      if state.walls.has_key?(cell_closest_to_mouse) or state.hills.has_key?(cell_closest_to_mouse)
+        state.walls.delete(cell_closest_to_mouse)
+        state.hills.delete(cell_closest_to_mouse)
+        reset_search
+      end
+    end
   end
 
-  # Prints the title onto the screen by using a label.
-  # Also separates the title from the grid with a line as a horizontal separator.
-  def print_title
-    args.outputs.labels << [ 640, 700, 'Paint!', 0, 1 ]
-    outputs.lines << horizontal_separator(660, 0, 1280)
+  # Removes walls in the second grid that are under the cursor
+  def input_remove_wall2
+    # The mouse needs to be inside the grid, because we only want to remove walls
+    # the cursor is directly over
+    # Recalculations should only occur when a wall is actually deleted
+    if mouse_over_grid2?
+      if state.walls.has_key?(cell_closest_to_mouse2) or state.hills.has_key?(cell_closest_to_mouse2)
+        state.walls.delete(cell_closest_to_mouse2)
+        state.hills.delete(cell_closest_to_mouse2)
+        reset_search
+      end
+    end
   end
 
-  # Sets the starting position, ending position, and color for the horizontal separator.
-  # The starting and ending positions have the same y values.
-  def horizontal_separator y, x, x2
-    [x, y, x2, y, 150, 150, 150]
+  # Adds a hill in the first grid in the cell the mouse is over
+  def input_add_hill
+    if mouse_over_grid?
+      unless state.hills.has_key?(cell_closest_to_mouse)
+        state.hills[cell_closest_to_mouse] = true
+        reset_search
+      end
+    end
   end
 
-  # Sets the starting position, ending position, and color for the vertical separator.
-  # The starting and ending positions have the same x values.
-  def vertical_separator x, y, y2
-    [x, y, x, y2, 150, 150, 150]
+
+  # Adds a hill in the second grid in the cell the mouse is over
+  def input_add_hill2
+    if mouse_over_grid2?
+      unless state.hills.has_key?(cell_closest_to_mouse2)
+        state.hills[cell_closest_to_mouse2] = true
+        reset_search
+      end
+    end
   end
 
-  # Outputs a border and a grid containing empty squares onto the screen.
-  def add_grid
+  # Adds a wall in the first grid in the cell the mouse is over
+  def input_add_wall
+    if mouse_over_grid?
+      unless state.walls.has_key?(cell_closest_to_mouse)
+        state.hills.delete(cell_closest_to_mouse)
+        state.walls[cell_closest_to_mouse] = true
+        reset_search
+      end
+    end
+  end
 
-    # Sets the x, y, height, and width of the grid.
-    # There are 31 horizontal lines and 31 vertical lines in the grid.
-    # Feel free to count them yourself before continuing!
-    x, y, h, w = 640 - 500/2, 640 - 500, 500, 500 # calculations done so the grid appears in screen's center
-    lines_h = 31
-    lines_v = 31
+  # Adds a wall in the second grid in the cell the mouse is over
+  def input_add_wall2
+    if mouse_over_grid2?
+      unless state.walls.has_key?(cell_closest_to_mouse2)
+        state.hills.delete(cell_closest_to_mouse2)
+        state.walls[cell_closest_to_mouse2] = true
+        reset_search
+      end
+    end
+  end
 
-    # Sets values for the grid's border, grid lines, and filled squares.
-    # The filled_squares variable is initially set to an empty array.
-    state.grid_border ||= [ x, y, h, w ] # definition of grid's outer border
-    state.grid_lines ||= draw_grid(x, y, h, w, lines_h, lines_v) # calls draw_grid method
-    state.filled_squares ||= [] # there are no filled squares until the user fills them in
+  # Whenever the user edits the grid,
+  # The search has to be reset_searchd upto the current step
+  # with the current grid as the initial state of the grid
+  def reset_search
+    breadth_first_search.visited    = {}
+    breadth_first_search.frontier   = []
+    breadth_first_search.came_from  = {}
 
-    # Outputs the grid lines, border, and filled squares onto the screen.
-    outputs.lines.concat state.grid_lines
-    outputs.borders << state.grid_border
-    outputs.solids << state.filled_squares
+    dijkstra_search.frontier    = []
+    dijkstra_search.came_from   = {}
+    dijkstra_search.cost_so_far = {}
   end
 
-  # Draws the grid by adding in vertical and horizontal separators.
-  def draw_grid x, y, h, w, lines_h, lines_v
 
-    # The grid starts off empty.
-    grid = []
 
-    # Calculates the placement and adds horizontal lines or separators into the grid.
-    curr_y = y # start at the bottom of the box
-    dist_y = h / (lines_h + 1) # finds distance to place horizontal lines evenly throughout 500 height of grid
-    lines_h.times do
-      curr_y += dist_y # increment curr_y by the distance between the horizontal lines
-      grid << horizontal_separator(curr_y, x, x + w - 1) # add a separator into the grid
-    end
+  # Returns a list of adjacent cells
+  # Used to determine what the next cells to be added to the frontier are
+  def adjacent_neighbors(cell)
+    neighbors = []
 
-    # Calculates the placement and adds vertical lines or separators into the grid.
-    curr_x = x # now start at the left of the box
-    dist_x = w / (lines_v + 1) # finds distance to place vertical lines evenly throughout 500 width of grid
-    lines_v.times do
-      curr_x += dist_x # increment curr_x by the distance between the vertical lines
-      grid << vertical_separator(curr_x, y + 1, y  + h) # add separator
-    end
+    # Gets all the valid neighbors into the array
+    # From southern neighbor, clockwise
+    neighbors << [cell.x    , cell.y - 1] unless cell.y == 0
+    neighbors << [cell.x - 1, cell.y    ] unless cell.x == 0
+    neighbors << [cell.x    , cell.y + 1] unless cell.y == grid.height - 1
+    neighbors << [cell.x + 1, cell.y    ] unless cell.x == grid.width - 1
 
-    # paint_grid uses a hash to assign values to keys.
-    state.paint_grid ||= {"x" => x, "y" => y, "h" => h, "w" => w, "lines_h" => lines_h,
-                          "lines_v" => lines_v, "dist_x" => dist_x,
-                          "dist_y" => dist_y }
+    # Sorts the neighbors so the rendered path is a zigzag path
+    # Cells in a diagonal direction are given priority
+    # Comment this line to see the difference
+    neighbors = neighbors.sort_by { |neighbor_x, neighbor_y|  proximity_to_star(neighbor_x, neighbor_y) }
 
-    return grid
+    neighbors
   end
 
-  # Checks if the user is keeping the mouse pressed down and sets the mouse_hold variable accordingly using boolean values.
-  # If the mouse is up, the user cannot drag the mouse.
-  def check_click
-    if inputs.mouse.down #is mouse up or down?
-      state.mouse_held = true # mouse is being held down
-    elsif inputs.mouse.up # if mouse is up
-    state.mouse_held = false # mouse is not being held down or dragged
-      state.mouse_dragging = false
-    end
+  # Finds the vertical and horizontal distance of a cell from the star
+  # and returns the larger value
+  # This method is used to have a zigzag pattern in the rendered path
+  # A cell that is [5, 5] from the star,
+  # is explored before over a cell that is [0, 7] away.
+  # So, if possible, the search tries to go diagonal (zigzag) first
+  def proximity_to_star(x, y)
+    distance_x = (state.star.x - x).abs
+    distance_y = (state.star.y - y).abs
 
-    if state.mouse_held &&    # mouse needs to be down
-      !inputs.mouse.click &&     # must not be first click
-      ((inputs.mouse.previous_click.point.x - inputs.mouse.position.x).abs > 15) # Need to move 15 pixels before "drag"
-      state.mouse_dragging = true
+    if distance_x > distance_y
+      return distance_x
+    else
+      return distance_y
     end
+  end
 
-    # If the user clicks their mouse inside the grid, the search_lines method is called with a click input type.
-    if ((inputs.mouse.click) && (inputs.mouse.click.point.inside_rect? state.grid_border))
-      search_lines(inputs.mouse.click.point, :click)
+  # When the user grabs the star and puts their cursor to the far right
+  # and moves up and down, the star is supposed to move along the grid as well
+  # Finding the cell closest to the mouse helps with this
+  def cell_closest_to_mouse
+    # Closest cell to the mouse in the first grid
+    x = (inputs.mouse.point.x / grid.cell_size).to_i
+    y = (inputs.mouse.point.y / grid.cell_size).to_i
+    # Bound x and y to the grid
+    x = grid.width - 1 if x > grid.width - 1
+    y = grid.height - 1 if y > grid.height - 1
+    # Return closest cell
+    [x, y]
+  end
 
-    # If the user drags their mouse inside the grid, the search_lines method is called with a drag input type.
-    elsif ((state.mouse_dragging) && (inputs.mouse.position.inside_rect? state.grid_border))
-      search_lines(inputs.mouse.position, :drag)
-    end
+  # When the user grabs the star and puts their cursor to the far right
+  # and moves up and down, the star is supposed to move along the grid as well
+  # Finding the cell closest to the mouse in the second grid helps with this
+  def cell_closest_to_mouse2
+    # Closest cell grid to the mouse in the second
+    x = (inputs.mouse.point.x / grid.cell_size).to_i
+    y = (inputs.mouse.point.y / grid.cell_size).to_i
+    # Translate the cell to the first grid
+    x -= grid.width + 1
+    # Bound x and y to the first grid
+    x = 0 if x < 0
+    y = 0 if y < 0
+    x = grid.width - 1 if x > grid.width - 1
+    y = grid.height - 1 if y > grid.height - 1
+    # Return closest cell
+    [x, y]
   end
 
-  # Sets the definition of a grid box and handles user input to fill in or clear grid boxes.
-  def search_lines (point, input_type)
-    point.x -= state.paint_grid["x"] # subtracts the value assigned to the "x" key in the paint_grid hash
-    point.y -= state.paint_grid["y"] # subtracts the value assigned to the "y" key in the paint_grid hash
+  # Signal that the user is going to be moving the star from the first grid
+  def mouse_over_star?
+    inputs.mouse.point.inside_rect?(scale_up(state.star))
+  end
 
-    # Remove code following the .floor and see what happens when you try to fill in grid squares
-    point.x = (point.x / state.paint_grid["dist_x"]).floor * state.paint_grid["dist_x"]
-    point.y = (point.y / state.paint_grid["dist_y"]).floor * state.paint_grid["dist_y"]
+  # Signal that the user is going to be moving the star from the second grid
+  def mouse_over_star2?
+    inputs.mouse.point.inside_rect?(move_and_scale_up(state.star))
+  end
 
-    point.x += state.paint_grid["x"]
-    point.y += state.paint_grid["y"]
+  # Signal that the user is going to be moving the target from the first grid
+  def mouse_over_target?
+    inputs.mouse.point.inside_rect?(scale_up(state.target))
+  end
 
-    # Sets definition of a grid box, meaning its x, y, width, and height.
-    # Floor is called on the point.x and point.y variables.
-    # Ceil method is called on values of the distance hash keys, setting the width and height of a box.
-    grid_box = [ point.x.floor, point.y.floor, state.paint_grid["dist_x"].ceil, state.paint_grid["dist_y"].ceil ]
+  # Signal that the user is going to be moving the target from the second grid
+  def mouse_over_target2?
+    inputs.mouse.point.inside_rect?(move_and_scale_up(state.target))
+  end
 
-    if input_type == :click # if user clicks their mouse
-      if state.filled_squares.include? grid_box # if grid box is already filled in
-        state.filled_squares.delete grid_box # box is cleared and removed from filled_squares
-      else
-        state.filled_squares << grid_box # otherwise, box is filled in and added to filled_squares
-      end
-    elsif input_type == :drag # if user drags mouse
-      unless state.filled_squares.include? grid_box # unless the grid box dragged over is already filled in
-        state.filled_squares << grid_box # the box is filled in and added to filled_squares
-      end
+  # Signal that the user is going to be removing walls from the first grid
+  def mouse_over_wall?
+    state.walls.each_key do | wall |
+      return true if inputs.mouse.point.inside_rect?(scale_up(wall))
     end
+
+    false
   end
 
-  # Creates and outputs a "Clear" button on the screen using a label and a border.
-  # If the button is clicked, the filled squares are cleared, making the filled_squares collection empty.
-  def draw_buttons
-    x, y, w, h = 390, 50, 240, 50
-    state.clear_button        ||= state.new_entity(:button_with_fade)
+  # Signal that the user is going to be removing walls from the second grid
+  def mouse_over_wall2?
+    state.walls.each_key do | wall |
+      return true if inputs.mouse.point.inside_rect?(move_and_scale_up(wall))
+    end
 
-    # The x and y positions are set to display the label in the center of the button.
-    # Try changing the first two parameters to simply x, y and see what happens to the text placement!
-    state.clear_button.label  ||= [x + w.half, y + h.half + 10, "Clear", 0, 1] # placed in center of border
-    state.clear_button.border ||= [x, y, w, h]
+    false
+  end
 
-    # If the mouse is clicked inside the borders of the clear button,
-    # the filled_squares collection is emptied and the squares are cleared.
-    if inputs.mouse.click && inputs.mouse.click.point.inside_rect?(state.clear_button.border)
-      state.clear_button.clicked_at = inputs.mouse.click.created_at # time (frame) the click occurred
-      state.filled_squares.clear
-      inputs.mouse.previous_click = nil
+  # Signal that the user is going to be removing hills from the first grid
+  def mouse_over_hill?
+    state.hills.each_key do | hill |
+      return true if inputs.mouse.point.inside_rect?(scale_up(hill))
     end
 
-    outputs.labels << state.clear_button.label
-    outputs.borders << state.clear_button.border
+    false
+  end
 
-    # When the clear button is clicked, the color of the button changes
-    # and the transparency changes, as well. If you change the time from
-    # 0.25.seconds to 1.25.seconds or more, the change will last longer.
-    if state.clear_button.clicked_at
-      outputs.solids << [x, y, w, h, 0, 180, 80, 255 * state.clear_button.clicked_at.ease(0.25.seconds, :flip)]
+  # Signal that the user is going to be removing hills from the second grid
+  def mouse_over_hill2?
+    state.hills.each_key do | hill |
+      return true if inputs.mouse.point.inside_rect?(move_and_scale_up(hill))
     end
-  end
-end
 
-$paint_app = PaintApp.new
+    false
+  end
 
-def tick args
-  $paint_app.inputs = args.inputs
-  $paint_app.state = args.state
-  $paint_app.grid = args.grid
-  $paint_app.args = args
-  $paint_app.outputs = args.outputs
-  $paint_app.tick
-  tick_instructions args, "How to create a simple paint app. CLICK and HOLD to draw."
-end
+  # Signal that the user is going to be adding walls from the first grid
+  def mouse_over_grid?
+    inputs.mouse.point.inside_rect?(scale_up(grid.rect))
+  end
 
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
+  # Signal that the user is going to be adding walls from the second grid
+  def mouse_over_grid2?
+    inputs.mouse.point.inside_rect?(move_and_scale_up(grid.rect))
   end
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
-end
+  # These methods provide handy aliases to colors
 
-
-Mouse - Coordinate Systems - main.rb
-# ./samples/05_mouse/04_coordinate_systems/app/main.rb
-=begin
+  # Light brown
+  def unvisited_color
+    [221, 212, 213]
+  end
 
- APIs listing that haven't been encountered in previous sample apps:
+  # Camo Green
+  def wall_color
+    [134, 134, 120]
+  end
 
- - args.inputs.mouse.click.position: Coordinates of the mouse's position on the screen.
-   Unlike args.inputs.mouse.click.point, the mouse does not need to be pressed down for
-   position to know the mouse's coordinates.
-   For more information about the mouse, go to mygame/documentation/07-mouse.md.
+  # Pastel White
+  def path_color
+    [231, 230, 228]
+  end
 
- Reminders:
+  def red
+    [255, 0, 0]
+  end
 
- - args.inputs.mouse.click: This property will be set if the mouse was clicked.
+  # A Green
+  def hill_color
+    [139, 173, 132]
+  end
 
- - args.inputs.mouse.click.point.(x|y): The x and y location of the mouse.
+  # Makes code more concise
+  def grid
+    state.grid
+  end
 
- - String interpolation: Uses #{} syntax; everything between the #{ and the } is evaluated
-   as Ruby code, and the placeholder is replaced with its corresponding value or result.
+  def breadth_first_search
+    state.breadth_first_search
+  end
 
-   In this sample app, string interpolation is used to show the current position of the mouse
-   in a label.
+  def dijkstra_search
+    state.dijkstra_search
+  end
+end
 
- - args.outputs.labels: An array that generates a label.
-   The parameters are [X, Y, TEXT, SIZE, ALIGN, RED, GREEN, BLUE, ALPHA, FONT STYLE]
-   For more information about labels, go to mygame/documentation/02-labels.md.
+# Method that is called by DragonRuby periodically
+# Used for updating animations and calculations
+def tick args
 
- - args.outputs.solids: An array that generates a solid.
-   The parameters are [X, Y, WIDTH, HEIGHT, RED, GREEN, BLUE, ALPHA]
-   For more information about solids, go to mygame/documentation/03-solids-and-borders.md.
+  # Pressing r will reset the application
+  if args.inputs.keyboard.key_down.r
+    args.gtk.reset
+    reset
+    return
+  end
 
- - args.outputs.lines: An array that generates a line.
-   The parameters are [X, Y, X2, Y2, RED, GREEN, BLUE, ALPHA]
-   For more information about lines, go to mygame/documentation/04-lines.md.
+  # Every tick, new args are passed, and the Dijkstra tick method is called
+  $movement_costs ||= Movement_Costs.new(args)
+  $movement_costs.args = args
+  $movement_costs.tick
+end
 
-=end
 
-# This sample app shows a coordinate system or grid. The user can move their mouse around the screen and the
-# coordinates of their position on the screen will be displayed. Users can choose to view one quadrant or
-# four quadrants by pressing the button.
+def reset
+  $movement_costs = nil
+end
 
-def tick args
+
+Path Finding Algorithms - Heuristic - main.rb
+# ./samples/13_path_finding_algorithms/06_heuristic/app/main.rb
+# This program is inspired by https://www.redblobgames.com/pathfinding/a-star/introduction.html
 
-  # The addition and subtraction in the first two parameters of the label and solid
-  # ensure that the outputs don't overlap each other. Try removing them and see what happens.
-  pos = args.inputs.mouse.position # stores coordinates of mouse's position
-  args.outputs.labels << [pos.x + 10, pos.y + 10, "#{pos}"] # outputs label of coordinates
-  args.outputs.solids << [pos.x -  2, pos.y - 2, 5, 5] # outputs small blackk box placed where mouse is hovering
+# This time the heuristic search still explored less of the grid, hence finishing faster.
+# However, it did not find the shortest path between the star and the target.
 
-  button = [0, 0, 370, 50] # sets definition of toggle button
-  args.outputs.borders << button # outputs button as border (not filled in)
-  args.outputs.labels << [10, 35, "click here toggle coordinate system"] # label of button
-  args.outputs.lines << [    0, -720,    0, 720] # vertical line dividing quadrants
-  args.outputs.lines << [-1280,    0, 1280,   0] # horizontal line dividing quadrants
+# The only difference between this app and Heuristic is the change of the starting position.
 
-  if args.inputs.mouse.click # if the user clicks the mouse
-    pos = args.inputs.mouse.click.point # pos's value is point where user clicked (coordinates)
-    if pos.inside_rect? button # if the click occurred inside the button
-      if args.grid.name == :bottom_left # if the grid shows bottom left as origin
-        args.grid.origin_center! # origin will be shown in center
-      else
-        args.grid.origin_bottom_left! # otherwise, the view will change to show bottom left as origin
-      end
+class Heuristic_With_Walls
+  attr_gtk
+
+  def tick
+    defaults
+    render
+    input
+    # If animation is playing, and max steps have not been reached
+    # Move the search a step forward
+    if state.play && state.current_step < state.max_steps
+      # Variable that tells the program what step to recalculate up to
+      state.current_step += 1
+      move_searches_one_step_forward
     end
   end
 
-  tick_instructions args, "Sample app shows the two supported coordinate systems in Game Toolkit."
-end
-
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
+  def defaults
+    # Variables to edit the size and appearance of the grid
+    # Freely customizable to user's liking
+    grid.width     ||= 15
+    grid.height    ||= 15
+    grid.cell_size ||= 40
+    grid.rect      ||= [0, 0, grid.width, grid.height]
+
+    grid.star      ||= [0, 2]
+    grid.target    ||= [14, 12]
+    grid.walls     ||= {}
+    # There are no hills in the Heuristic Search Demo
+
+    # What the user is currently editing on the grid
+    # We store this value, because we want to remember the value even when
+    # the user's cursor is no longer over what they're interacting with, but
+    # they are still clicking down on the mouse.
+    state.user_input ||= :none
+
+    # These variables allow the breadth first search to take place
+    # Came_from is a hash with a key of a cell and a value of the cell that was expanded from to find the key.
+    # Used to prevent searching cells that have already been found
+    # and to trace a path from the target back to the starting point.
+    # Frontier is an array of cells to expand the search from.
+    # The search is over when there are no more cells to search from.
+    # Path stores the path from the target to the star, once the target has been found
+    # It prevents calculating the path every tick.
+    bfs.came_from  ||= {}
+    bfs.frontier   ||= []
+    bfs.path       ||= []
+
+    heuristic.came_from ||= {}
+    heuristic.frontier  ||= []
+    heuristic.path      ||= []
+
+    # Stores which step of the animation is being rendered
+    # When the user moves the star or messes with the walls,
+    # the searches are recalculated up to this step
+
+    # Unless the current step has a value
+    unless state.current_step
+      # Set the current step to 10
+      state.current_step = 10
+      # And calculate the searches up to step 10
+      recalculate_searches
+    end
+
+    # At some step the animation will end,
+    # and further steps won't change anything (the whole grid will be explored)
+    # This step is roughly the grid's width * height
+    # When anim_steps equals max_steps no more calculations will occur
+    # and the slider will be at the end
+    state.max_steps = grid.width * grid.height
+
+    # Whether the animation should play or not
+    # If true, every tick moves anim_steps forward one
+    # Pressing the stepwise animation buttons will pause the animation
+    # An if statement instead of the ||= operator is used for assigning a boolean value.
+    # The || operator does not differentiate between nil and false.
+    if state.play == nil
+      state.play = false
+    end
+
+    # Store the rects of the buttons that control the animation
+    # They are here for user customization
+    # Editing these might require recentering the text inside them
+    # Those values can be found in the render_button methods
+    buttons.left   = [470, 600, 50, 50]
+    buttons.center = [520, 600, 200, 50]
+    buttons.right  = [720, 600, 50, 50]
+
+    # The variables below are related to the slider
+    # They allow the user to customize them
+    # They also give a central location for the render and input methods to get
+    # information from
+    # x & y are the coordinates of the leftmost part of the slider line
+    slider.x = 440
+    slider.y = 675
+    # This is the width of the line
+    slider.w = 360
+    # This is the offset for the circle
+    # Allows the center of the circle to be on the line,
+    # as opposed to the upper right corner
+    slider.offset = 20
+    # This is the spacing between each of the notches on the slider
+    # Notches are places where the circle can rest on the slider line
+    # There needs to be a notch for each step before the maximum number of steps
+    slider.spacing = slider.w.to_f / state.max_steps.to_f
+  end
+
+  # All methods with render draw stuff on the screen
+  # UI has buttons, the slider, and labels
+  # The search specific rendering occurs in the respective methods
+  def render
+    render_ui
+    render_bfs
+    render_heuristic
   end
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
-end
-
-

-Save Load - Save Load Game - main.rb
-# ./samples/06_save_load/01_save_load_game/app/main.rb
-=begin
-
- APIs listing that haven't been encountered in previous sample apps:
+  def render_ui
+    render_buttons
+    render_slider
+    render_labels
+  end
 
- - Symbol (:): Ruby object with a name and an internal ID. Symbols are useful
-   because with a given symbol name, you can refer to the same object throughout
-   a Ruby program.
+  def render_buttons
+    render_left_button
+    render_center_button
+    render_right_button
+  end
 
-   In this sample app, we're using symbols for our buttons. We have buttons that
-   light fires, save, load, etc. Each of these buttons has a distinct symbol like
-   :light_fire, :save_game, :load_game, etc.
+  def render_bfs
+    render_bfs_grid
+    render_bfs_star
+    render_bfs_target
+    render_bfs_visited
+    render_bfs_walls
+    render_bfs_frontier
+    render_bfs_path
+  end
 
- - to_sym: Returns the symbol corresponding to the given string; creates the symbol
-   if it does not already exist.
-   For example,
-   'car'.to_sym
-   would return the symbol :car.
+  def render_heuristic
+    render_heuristic_grid
+    render_heuristic_star
+    render_heuristic_target
+    render_heuristic_visited
+    render_heuristic_walls
+    render_heuristic_frontier
+    render_heuristic_path
+  end
 
- - last: Returns the last element of an array.
+  # This method handles user input every tick
+  def input
+    # Check and handle button input
+    input_buttons
 
- Reminders:
+    # If the mouse was lifted this tick
+    if inputs.mouse.up
+      # Set current input to none
+      state.user_input = :none
+    end
 
- - num1.lesser(num2): finds the lower value of the given options.
-   For example, in the statement
-   a = 4.lesser(3)
-   3 has a lower value than 4, which means that the value of a would be set to 3,
-   but if the statement had been
-   a = 4.lesser(5)
-   4 has a lower value than 5, which means that the value of a would be set to 4.
+    # If the mouse was clicked this tick
+    if inputs.mouse.down
+      # Determine what the user is editing and appropriately edit the state.user_input variable
+      determine_input
+    end
 
- - num1.fdiv(num2): returns the float division (will have a decimal) of the two given numbers.
-   For example, 5.fdiv(2) = 2.5 and 5.fdiv(5) = 1.0
+    # Process user input based on user_input variable and current mouse position
+    process_input
+  end
 
- - String interpolation: uses #{} syntax; everything between the #{ and the } is evaluated
-   as Ruby code, and the placeholder is replaced with its corresponding value or result.
+  # Determines what the user is editing
+  # This method is called when the mouse is clicked down
+  def determine_input
+    if mouse_over_slider?
+      state.user_input = :slider
+    # If the mouse is over the star in the first grid
+    elsif bfs_mouse_over_star?
+      # The user is editing the star from the first grid
+      state.user_input = :bfs_star
+    # If the mouse is over the star in the second grid
+    elsif heuristic_mouse_over_star?
+      # The user is editing the star from the second grid
+      state.user_input = :heuristic_star
+    # If the mouse is over the target in the first grid
+    elsif bfs_mouse_over_target?
+      # The user is editing the target from the first grid
+      state.user_input = :bfs_target
+    # If the mouse is over the target in the second grid
+    elsif heuristic_mouse_over_target?
+      # The user is editing the target from the second grid
+      state.user_input = :heuristic_target
+    # If the mouse is over a wall in the first grid
+    elsif bfs_mouse_over_wall?
+      # The user is removing a wall from the first grid
+      state.user_input = :bfs_remove_wall
+    # If the mouse is over a wall in the second grid
+    elsif heuristic_mouse_over_wall?
+      # The user is removing a wall from the second grid
+      state.user_input = :heuristic_remove_wall
+    # If the mouse is over the first grid
+    elsif bfs_mouse_over_grid?
+      # The user is adding a wall from the first grid
+      state.user_input = :bfs_add_wall
+    # If the mouse is over the second grid
+    elsif heuristic_mouse_over_grid?
+      # The user is adding a wall from the second grid
+      state.user_input = :heuristic_add_wall
+    end
+  end
+
+  # Processes click and drag based on what the user is currently dragging
+  def process_input
+    if state.user_input == :slider
+      process_input_slider
+    elsif state.user_input == :bfs_star
+      process_input_bfs_star
+    elsif state.user_input == :heuristic_star
+      process_input_heuristic_star
+    elsif state.user_input == :bfs_target
+      process_input_bfs_target
+    elsif state.user_input == :heuristic_target
+      process_input_heuristic_target
+    elsif state.user_input == :bfs_remove_wall
+      process_input_bfs_remove_wall
+    elsif state.user_input == :heuristic_remove_wall
+      process_input_heuristic_remove_wall
+    elsif state.user_input == :bfs_add_wall
+      process_input_bfs_add_wall
+    elsif state.user_input == :heuristic_add_wall
+      process_input_heuristic_add_wall
+    end
+  end
 
- - args.outputs.labels: An array. Values generate a label.
-   Parameters are [X, Y, TEXT, SIZE, ALIGN, RED, GREEN, BLUE, ALPHA, FONT STYLE]
-   For more information, go to mygame/documentation/02-labels.md.
+  def render_slider
+    # Using primitives hides the line under the white circle of the slider
+    # Draws the line
+    outputs.primitives << [slider.x, slider.y, slider.x + slider.w, slider.y].line
+    # The circle needs to be offset so that the center of the circle
+    # overlaps the line instead of the upper right corner of the circle
+    # The circle's x value is also moved based on the current seach step
+    circle_x = (slider.x - slider.offset) + (state.current_step * slider.spacing)
+    circle_y = (slider.y - slider.offset)
+    circle_rect = [circle_x, circle_y, 37, 37]
+    outputs.primitives << [circle_rect, 'circle-white.png'].sprite
+  end
 
- - ARRAY#inside_rect?: An array with at least two values is considered a point. An array
-   with at least four values is considered a rect. The inside_rect? function returns true
-   or false depending on if the point is inside the rect.
+  def render_labels
+    outputs.labels << [205, 625, "Breadth First Search"]
+    outputs.labels << [820, 625, "Heuristic Best-First Search"]
+  end
 
-=end
+  def render_left_button
+    # Draws the button_color button, and a black border
+    # The border separates the buttons visually
+    outputs.solids  << [buttons.left, button_color]
+    outputs.borders << [buttons.left]
 
-# This code allows users to perform different tasks, such as saving and loading the game.
-# Users also have options to reset the game and light a fire.
+    # Renders an explanatory label in the center of the button
+    # Explains to the user what the button does
+    # If the button size is changed, the label might need to be edited as well
+    # to keep the label in the center of the button
+    label_x = buttons.left.x + 20
+    label_y = buttons.left.y + 35
+    outputs.labels  << [label_x, label_y, "<"]
+  end
 
-class TextedBasedGame
+  def render_center_button
+    # Draws the button_color button, and a black border
+    # The border separates the buttons visually
+    outputs.solids  << [buttons.center, button_color]
+    outputs.borders << [buttons.center]
 
-  # Contains methods needed for game to run properly.
-  # Increments tick count by 1 each time it runs (60 times in a single second)
-  def tick
-    default
-    show_intro
-    state.engine_tick_count += 1
-    tick_fire
+    # Renders an explanatory label in the center of the button
+    # Explains to the user what the button does
+    # If the button size is changed, the label might need to be edited as well
+    # to keep the label in the center of the button
+    label_x    = buttons.center.x + 37
+    label_y    = buttons.center.y + 35
+    label_text = state.play ? "Pause Animation" : "Play Animation"
+    outputs.labels << [label_x, label_y, label_text]
   end
 
-  # Sets default values.
-  # The ||= ensures that a variable's value is only set to the value following the = sign
-  # if the value has not already been set before. Intialization happens only in the first frame.
-  def default
-    state.engine_tick_count ||= 0
-    state.active_module     ||= :room
-    state.fire_progress     ||= 0
-    state.fire_ready_in     ||= 10
-    state.previous_fire     ||= :dead
-    state.fire              ||= :dead
+  def render_right_button
+    # Draws the button_color button, and a black border
+    # The border separates the buttons visually
+    outputs.solids  << [buttons.right, button_color]
+    outputs.borders << [buttons.right]
+
+    # Renders an explanatory label in the center of the button
+    # Explains to the user what the button does
+    label_x = buttons.right.x + 20
+    label_y = buttons.right.y + 35
+    outputs.labels  << [label_x, label_y, ">"]
   end
 
-  def show_intro
-    return unless state.engine_tick_count == 0 # return unless the game just started
-    set_story_line "awake." # calls set_story_line method, sets to "awake"
+  def render_bfs_grid
+    # A large rect the size of the grid
+    outputs.solids << [bfs_scale_up(grid.rect), default_color]
+
+    # The vertical grid lines
+    for x in 0..grid.width
+      outputs.lines << bfs_vertical_line(x)
+    end
+
+    # The horizontal grid lines
+    for y in 0..grid.height
+      outputs.lines << bfs_horizontal_line(y)
+    end
   end
 
-  # Sets story line.
-  def set_story_line story_line
-    state.story_line    = story_line # story line set to value of parameter
-    state.active_module = :alert # active module set to alert
+  def render_heuristic_grid
+    # A large rect the size of the grid
+    outputs.solids << [heuristic_scale_up(grid.rect), default_color]
+
+    # The vertical grid lines
+    for x in 0..grid.width
+      outputs.lines << heuristic_vertical_line(x)
+    end
+
+    # The horizontal grid lines
+    for y in 0..grid.height
+      outputs.lines << heuristic_horizontal_line(y)
+    end
   end
 
-  # Clears story line.
-  def clear_storyline
-    state.active_module = :none # active module set to none
-    state.story_line = nil # story line is cleared, set to nil (or empty)
+  # Returns a vertical line for a column of the first grid
+  def bfs_vertical_line column
+    bfs_scale_up([column, 0, column, grid.height])
   end
 
-  # Determines fire progress (how close the fire is to being ready to light).
-  def tick_fire
-    return if state.active_module == :alert # return if active module is alert
-    state.fire_progress += 1 # increment fire progress
-    # fire_ready_in is 10. The fire_progress is either the current value or 10, whichever has a lower value.
-    state.fire_progress = state.fire_progress.lesser(state.fire_ready_in)
+  # Returns a horizontal line for a column of the first grid
+  def bfs_horizontal_line row
+    bfs_scale_up([0, row, grid.width, row])
   end
 
-  # Sets the value of fire (whether it is dead or roaring), and the story line
-  def light_fire
-    return unless fire_ready? # returns unless the fire is ready to be lit
-    state.fire = :roaring # fire is lit, set to roaring
-    state.fire_progress = 0 # the fire progress returns to 0, since the fire has been lit
-    if state.fire != state.previous_fire
-      set_story_line "the fire is #{state.fire}." # the story line is set using string interpolation
-      state.previous_fire = state.fire
-    end
+  # Returns a vertical line for a column of the second grid
+  def heuristic_vertical_line column
+    bfs_scale_up([column + grid.width + 1, 0, column + grid.width + 1, grid.height])
   end
 
-  # Checks if the fire is ready to be lit. Returns a boolean value.
-  def fire_ready?
-    # If fire_progress (value between 0 and 10) is equal to fire_ready_in (value of 10),
-    # the fire is ready to be lit.
-    state.fire_progress == state.fire_ready_in
+  # Returns a horizontal line for a column of the second grid
+  def heuristic_horizontal_line row
+    bfs_scale_up([grid.width + 1, row, grid.width + grid.width + 1, row])
   end
 
-  # Divides the value of the fire_progress variable by 10 to determine how close the user is to
-  # being able to light a fire.
-  def light_fire_progress
-    state.fire_progress.fdiv(10) # float division
+  # Renders the star on the first grid
+  def render_bfs_star
+    outputs.sprites << [bfs_scale_up(grid.star), 'star.png']
   end
 
-  # Defines fire as the state.fire variable.
-  def fire
-    state.fire
+  # Renders the star on the second grid
+  def render_heuristic_star
+    outputs.sprites << [heuristic_scale_up(grid.star), 'star.png']
   end
 
-  # Sets the title of the room.
-  def room_title
-    return "a room that is dark" if state.fire == :dead # room is dark if the fire is dead
-    return "a room that is lit" # room is lit if the fire is not dead
+  # Renders the target on the first grid
+  def render_bfs_target
+    outputs.sprites << [bfs_scale_up(grid.target), 'target.png']
   end
 
-  # Sets the active_module to room.
-  def go_to_room
-    state.active_module = :room
+  # Renders the target on the second grid
+  def render_heuristic_target
+    outputs.sprites << [heuristic_scale_up(grid.target), 'target.png']
   end
 
-  # Defines active_module as the state.active_module variable.
-  def active_module
-    state.active_module
+  # Renders the walls on the first grid
+  def render_bfs_walls
+    grid.walls.each_key do | wall |
+      outputs.solids << [bfs_scale_up(wall), wall_color]
+    end
   end
 
-  # Defines story_line as the state.story_line variable.
-  def story_line
-    state.story_line
+  # Renders the walls on the second grid
+  def render_heuristic_walls
+    grid.walls.each_key do | wall |
+      outputs.solids << [heuristic_scale_up(wall), wall_color]
+    end
   end
 
-  # Update every 60 frames (or every second)
-  def should_tick?
-    state.tick_count.mod_zero?(60)
+  # Renders the visited cells on the first grid
+  def render_bfs_visited
+    bfs.came_from.each_key do | visited_cell |
+      outputs.solids << [bfs_scale_up(visited_cell), visited_color]
+    end
   end
 
-  # Sets the value of the game state provider.
-  def initialize game_state_provider
-    @game_state_provider = game_state_provider
+  # Renders the visited cells on the second grid
+  def render_heuristic_visited
+    heuristic.came_from.each_key do | visited_cell |
+      outputs.solids << [heuristic_scale_up(visited_cell), visited_color]
+    end
   end
 
-  # Defines the game state.
-  # Any variable prefixed with an @ symbol is an instance variable.
-  def state
-    @game_state_provider.state
+  # Renders the frontier cells on the first grid
+  def render_bfs_frontier
+    bfs.frontier.each do | frontier_cell |
+      outputs.solids << [bfs_scale_up(frontier_cell), frontier_color, 200]
+    end
   end
 
-  # Saves the state of the game in a text file called game_state.txt.
-  def save
-    $gtk.serialize_state('game_state.txt', state)
+  # Renders the frontier cells on the second grid
+  def render_heuristic_frontier
+    heuristic.frontier.each do | frontier_cell |
+      outputs.solids << [heuristic_scale_up(frontier_cell), frontier_color, 200]
+    end
   end
 
-  # Loads the game state from the game_state.txt text file.
-  # If the load is unsuccessful, the user is informed since the story line indicates the failure.
-  def load
-    parsed_state = $gtk.deserialize_state('game_state.txt')
-    if !parsed_state
-      set_story_line "no game to load. press save first."
-    else
-      $gtk.args.state = parsed_state
+  # Renders the path found by the breadth first search on the first grid
+  def render_bfs_path
+    bfs.path.each do | path |
+      outputs.solids << [bfs_scale_up(path), path_color]
     end
   end
 
-  # Resets the game.
-  def reset
-    $gtk.reset
+  # Renders the path found by the heuristic search on the second grid
+  def render_heuristic_path
+    heuristic.path.each do | path |
+      outputs.solids << [heuristic_scale_up(path), path_color]
+    end
   end
-end
 
-class TextedBasedGamePresenter
-  attr_accessor :state, :outputs, :inputs
+  # Returns the rect for the path between two cells based on their relative positions
+  def get_path_between(cell_one, cell_two)
+    path = nil
 
-  # Creates empty collection called highlights.
-  # Calls methods necessary to run the game.
-  def tick
-    state.layout.highlights ||= []
-    game.tick if game.should_tick?
-    render
-    process_input
-  end
+    # If cell one is above cell two
+    if cell_one.x == cell_two.x and cell_one.y > cell_two.y
+      # Path starts from the center of cell two and moves upward to the center of cell one
+      path = [cell_two.x + 0.3, cell_two.y + 0.3, 0.4, 1.4]
+    # If cell one is below cell two
+    elsif cell_one.x == cell_two.x and cell_one.y < cell_two.y
+      # Path starts from the center of cell one and moves upward to the center of cell two
+      path = [cell_one.x + 0.3, cell_one.y + 0.3, 0.4, 1.4]
+    # If cell one is to the left of cell two
+    elsif cell_one.x > cell_two.x and cell_one.y == cell_two.y
+      # Path starts from the center of cell two and moves rightward to the center of cell one
+      path = [cell_two.x + 0.3, cell_two.y + 0.3, 1.4, 0.4]
+    # If cell one is to the right of cell two
+    elsif cell_one.x < cell_two.x and cell_one.y == cell_two.y
+      # Path starts from the center of cell one and moves rightward to the center of cell two
+      path = [cell_one.x + 0.3, cell_one.y + 0.3, 1.4, 0.4]
+    end
 
-  # Outputs a label of the tick count (passage of time) and calls all render methods.
-  def render
-    outputs.labels << [10, 30, state.tick_count]
-    render_alert
-    render_room
-    render_highlights
+    path
   end
 
-  # Outputs a label onto the screen that shows the story line, and also outputs a "close" button.
-  def render_alert
-    return unless game.active_module == :alert
+  # In code, the cells are represented as 1x1 rectangles
+  # When drawn, the cells are larger than 1x1 rectangles
+  # This method is used to scale up cells, and lines
+  # Objects are scaled up according to the grid.cell_size variable
+  # This allows for easy customization of the visual scale of the grid
+  # This method scales up cells for the first grid
+  def bfs_scale_up(cell)
+    # Prevents the original value of cell from being edited
+    cell = cell.clone
 
-    outputs.labels << [640, 480, game.story_line, 5, 1]  # outputs story line label
-    outputs.primitives << button(:alert_dismiss, 490, 380, "close")  # positions "close" button under story line
+    # If cell is just an x and y coordinate
+    if cell.size == 2
+      # Add a width and height of 1
+      cell << 1
+      cell << 1
+    end
+
+    # Scale all the values up
+    cell.map! { |value| value * grid.cell_size }
+
+    # Returns the scaled up cell
+    cell
   end
 
-  def render_room
-    return unless game.active_module == :room
-    outputs.labels << [640, 700, game.room_title, 4, 1] # outputs room title label at top of screen
+  # Translates the given cell grid.width + 1 to the right and then scales up
+  # Used to draw cells for the second grid
+  # This method does not work for lines,
+  # so separate methods exist for the grid lines
+  def heuristic_scale_up(cell)
+    # Prevents the original value of cell from being edited
+    cell = cell.clone
+    # Translates the cell to the second grid equivalent
+    cell.x += grid.width + 1
+    # Proceeds as if scaling up for the first grid
+    bfs_scale_up(cell)
+  end
 
-    # The parameters for these outputs are (symbol, x, y, text, value/percentage) and each has a y value
-    # that positions it 60 pixels lower than the previous output.
+  # Checks and handles input for the buttons
+  # Called when the mouse is lifted
+  def input_buttons
+    input_left_button
+    input_center_button
+    input_right_button
+  end
 
-    # outputs the light_fire_progress bar, uses light_fire_progress for its percentage (which changes bar's appearance)
-    outputs.primitives << progress_bar(:light_fire, 490, 600, "light fire", game.light_fire_progress)
-    outputs.primitives << button(       :save_game, 490, 540, "save") # outputs save button
-    outputs.primitives << button(       :load_game, 490, 480, "load") # outputs load button
-    outputs.primitives << button(      :reset_game, 490, 420, "reset") # outputs reset button
-    outputs.labels << [640, 30, "the fire is #{game.fire}", 0, 1] # outputs fire label at bottom of screen
+  # Checks if the previous step button is clicked
+  # If it is, it pauses the animation and moves the search one step backward
+  def input_left_button
+    if left_button_clicked?
+      state.play = false
+      state.current_step -= 1
+      recalculate_searches
+    end
   end
 
-  # Outputs a collection of highlights using an array to set their values, and also rejects certain values from the collection.
-  def render_highlights
-    state.layout.highlights.each do |h| # for each highlight in the collection
-        h.lifetime -= 1 # decrease the value of its lifetime
-      end
+  # Controls the play/pause button
+  # Inverses whether the animation is playing or not when clicked
+  def input_center_button
+    if center_button_clicked? || inputs.keyboard.key_down.space
+      state.play = !state.play
+    end
+  end
 
-      outputs.solids << state.layout.highlights.map do |h| # outputs highlights collection
-        [h.x, h.y, h.w, h.h, h.color, 255 * h.lifetime / h.max_lifetime] # sets definition for each highlight
-        # transparency changes; divide lifetime by max_lifetime, multiply result by 255
-      end
+  # Checks if the next step button is clicked
+  # If it is, it pauses the animation and moves the search one step forward
+  def input_right_button
+    if right_button_clicked?
+      state.play = false
+      state.current_step += 1
+      move_searches_one_step_forward
+    end
+  end
 
-      # reject highlights from collection that have no remaining lifetime
-      state.layout.highlights = state.layout.highlights.reject { |h| h.lifetime <= 0 }
+  # These methods detect when the buttons are clicked
+  def left_button_clicked?
+    inputs.mouse.point.inside_rect?(buttons.left) && inputs.mouse.up
   end
 
-  # Checks whether or not a button was clicked.
-  # Returns a boolean value.
-  def process_input
-    button = button_clicked? # calls button_clicked? method
+  def center_button_clicked?
+    inputs.mouse.point.inside_rect?(buttons.center) && inputs.mouse.up
   end
 
-  # Returns a boolean value.
-  # Finds the button that was clicked from the button list and determines what method to call.
-  # Adds a highlight to the highlights collection.
-  def button_clicked?
-    return nil unless click_pos # return nil unless click_pos holds coordinates of mouse click
-      button = @button_list.find do |k, v| # goes through button_list to find button clicked
-        click_pos.inside_rect? v[:primitives].last.rect # was the mouse clicked inside the rect of button?
-      end
-      return unless button # return unless a button was clicked
-      method_to_call = "#{button[0]}_clicked".to_sym # sets method_to_call to symbol (like :save_game or :load_game)
-      if self.respond_to? method_to_call # returns true if self responds to the given method (method actually exists)
-        border = button[1][:primitives].last # sets border definition using value of last key in button list hash
+  def right_button_clicked?
+    inputs.mouse.point.inside_rect?(buttons.right) && inputs.mouse.up
+  end
 
-        # declares each highlight as a new entity, sets properties
-        state.layout.highlights << state.new_entity(:highlight) do |h|
-            h.x = border.x
-            h.y = border.y
-            h.w = border.w
-            h.h = border.h
-            h.max_lifetime = 10
-            h.lifetime = h.max_lifetime
-            h.color = [120, 120, 180] # sets color to shade of purple
-          end
 
-          self.send method_to_call # invoke method identified by symbol
-        else # otherwise, if self doesn't respond to given method
-          border = button[1][:primitives].last # sets border definition using value of last key in hash
+  # Signal that the user is going to be moving the slider
+  # Is the mouse over the circle of the slider?
+  def mouse_over_slider?
+    circle_x = (slider.x - slider.offset) + (state.current_step * slider.spacing)
+    circle_y = (slider.y - slider.offset)
+    circle_rect = [circle_x, circle_y, 37, 37]
+    inputs.mouse.point.inside_rect?(circle_rect)
+  end
 
-          # declares each highlight as a new entity, sets properties
-          state.layout.highlights << state.new_entity(:highlight) do |h|
-            h.x = border.x
-            h.y = border.y
-            h.w = border.w
-            h.h = border.h
-            h.max_lifetime = 4 # different max_lifetime than the one set if respond_to? had been true
-            h.lifetime = h.max_lifetime
-            h.color = [120, 80, 80] # sets color to dark color
-          end
+  # Signal that the user is going to be moving the star from the first grid
+  def bfs_mouse_over_star?
+    inputs.mouse.point.inside_rect?(bfs_scale_up(grid.star))
+  end
 
-          # instructions for users on how to add the missing method_to_call to the code
-          puts "It looks like #{method_to_call} doesn't exists on TextedBasedGamePresenter. Please add this method:"
-          puts "Just copy the code below and put it in the #{TextedBasedGamePresenter} class definition."
-          puts ""
-          puts "```"
-          puts "class TextedBasedGamePresenter <--- find this class and put the method below in it"
-          puts ""
-          puts "  def #{method_to_call}"
-          puts "    puts 'Yay that worked!'"
-          puts "  end"
-          puts ""
-          puts "end <-- make sure to put the #{method_to_call} method in between the `class` word and the final `end` statement."
-          puts "```"
-          puts ""
-      end
+  # Signal that the user is going to be moving the star from the second grid
+  def heuristic_mouse_over_star?
+    inputs.mouse.point.inside_rect?(heuristic_scale_up(grid.star))
   end
 
-  # Returns the position of the mouse when it is clicked.
-  def click_pos
-    return nil unless inputs.mouse.click # returns nil unless the mouse was clicked
-    return inputs.mouse.click.point # returns location of mouse click (coordinates)
+  # Signal that the user is going to be moving the target from the first grid
+  def bfs_mouse_over_target?
+    inputs.mouse.point.inside_rect?(bfs_scale_up(grid.target))
   end
 
-  # Creates buttons for the button_list and sets their values using a hash (uses symbols as keys)
-  def button id, x, y, text
-    @button_list[id] ||= { # assigns values to hash keys
-      id: id,
-      text: text,
-      primitives: [
-        [x + 10, y + 30, text, 2, 0].label, # positions label inside border
-        [x, y, 300, 50].border,             # sets definition of border
-      ]
-    }
+  # Signal that the user is going to be moving the target from the second grid
+  def heuristic_mouse_over_target?
+    inputs.mouse.point.inside_rect?(heuristic_scale_up(grid.target))
+  end
 
-    @button_list[id][:primitives] # returns label and border for buttons
+  # Signal that the user is going to be removing walls from the first grid
+  def bfs_mouse_over_wall?
+    grid.walls.each_key do | wall |
+      return true if inputs.mouse.point.inside_rect?(bfs_scale_up(wall))
+    end
+
+    false
   end
 
-  # Creates a progress bar (used for lighting the fire) and sets its values.
-  def progress_bar id, x, y, text, percentage
-    @button_list[id] = { # assigns values to hash keys
-      id: id,
-      text: text,
-      primitives: [
-        [x, y, 300, 50, 100, 100, 100].solid, # sets definition for solid (which fills the bar with gray)
-        [x + 10, y + 30, text, 2, 0].label, # sets definition for label, positions inside border
-        [x, y, 300, 50].border, # sets definition of border
-      ]
-    }
+  # Signal that the user is going to be removing walls from the second grid
+  def heuristic_mouse_over_wall?
+    grid.walls.each_key do | wall |
+      return true if inputs.mouse.point.inside_rect?(heuristic_scale_up(wall))
+    end
 
-    # Fills progress bar based on percentage. If the fire was ready to be lit (100%) and we multiplied by
-    # 100, only 1/3 of the bar would only be filled in. 200 would cause only 2/3 to be filled in.
-    @button_list[id][:primitives][0][2] = 300 * percentage
-    @button_list[id][:primitives]
+    false
   end
 
-  # Defines the game.
-  def game
-    @game
+  # Signal that the user is going to be adding walls from the first grid
+  def bfs_mouse_over_grid?
+    inputs.mouse.point.inside_rect?(bfs_scale_up(grid.rect))
   end
 
-  # Initalizes the game and creates an empty list of buttons.
-  def initialize
-    @game = TextedBasedGame.new self
-    @button_list ||= {}
+  # Signal that the user is going to be adding walls from the second grid
+  def heuristic_mouse_over_grid?
+    inputs.mouse.point.inside_rect?(heuristic_scale_up(grid.rect))
   end
 
-  # Clears the storyline and takes the user to the room.
-  def alert_dismiss_clicked
-    game.clear_storyline
-    game.go_to_room
+  # This method is called when the user is editing the slider
+  # It pauses the animation and moves the white circle to the closest integer point
+  # on the slider
+  # Changes the step of the search to be animated
+  def process_input_slider
+    state.play = false
+    mouse_x = inputs.mouse.point.x
+
+    # Bounds the mouse_x to the closest x value on the slider line
+    mouse_x = slider.x if mouse_x < slider.x
+    mouse_x = slider.x + slider.w if mouse_x > slider.x + slider.w
+
+    # Sets the current search step to the one represented by the mouse x value
+    # The slider's circle moves due to the render_slider method using anim_steps
+    state.current_step = ((mouse_x - slider.x) / slider.spacing).to_i
+
+    recalculate_searches
   end
 
-  # Lights the fire when the user clicks the "light fire" option.
-  def light_fire_clicked
-    game.light_fire
+  # Moves the star to the cell closest to the mouse in the first grid
+  # Only resets the search if the star changes position
+  # Called whenever the user is editing the star (puts mouse down on star)
+  def process_input_bfs_star
+    old_star = grid.star.clone
+    unless bfs_cell_closest_to_mouse == grid.target
+      grid.star = bfs_cell_closest_to_mouse
+    end
+    unless old_star == grid.star
+      recalculate_searches
+    end
   end
 
-  # Saves the game when the user clicks the "save" option.
-  def save_game_clicked
-    game.save
+  # Moves the star to the cell closest to the mouse in the second grid
+  # Only resets the search if the star changes position
+  # Called whenever the user is editing the star (puts mouse down on star)
+  def process_input_heuristic_star
+    old_star = grid.star.clone
+    unless heuristic_cell_closest_to_mouse == grid.target
+      grid.star = heuristic_cell_closest_to_mouse
+    end
+    unless old_star == grid.star
+      recalculate_searches
+    end
   end
 
-  # Resets the game when the user clicks the "reset" option.
-  def reset_game_clicked
-    game.reset
+  # Moves the target to the grid closest to the mouse in the first grid
+  # Only recalculate_searchess the search if the target changes position
+  # Called whenever the user is editing the target (puts mouse down on target)
+  def process_input_bfs_target
+    old_target = grid.target.clone
+    unless bfs_cell_closest_to_mouse == grid.star
+      grid.target = bfs_cell_closest_to_mouse
+    end
+    unless old_target == grid.target
+      recalculate_searches
+    end
   end
 
-  # Loads the game when the user clicks the "load" option.
-  def load_game_clicked
-    game.load
+  # Moves the target to the cell closest to the mouse in the second grid
+  # Only recalculate_searchess the search if the target changes position
+  # Called whenever the user is editing the target (puts mouse down on target)
+  def process_input_heuristic_target
+    old_target = grid.target.clone
+    unless heuristic_cell_closest_to_mouse == grid.star
+      grid.target = heuristic_cell_closest_to_mouse
+    end
+    unless old_target == grid.target
+      recalculate_searches
+    end
   end
-end
 
-$text_based_rpg = TextedBasedGamePresenter.new
+  # Removes walls in the first grid that are under the cursor
+  def process_input_bfs_remove_wall
+    # The mouse needs to be inside the grid, because we only want to remove walls
+    # the cursor is directly over
+    # Recalculations should only occur when a wall is actually deleted
+    if bfs_mouse_over_grid?
+      if grid.walls.has_key?(bfs_cell_closest_to_mouse)
+        grid.walls.delete(bfs_cell_closest_to_mouse)
+        recalculate_searches
+      end
+    end
+  end
 
-def tick args
-  $text_based_rpg.state = args.state
-  $text_based_rpg.outputs = args.outputs
-  $text_based_rpg.inputs = args.inputs
-  $text_based_rpg.tick
-end
+  # Removes walls in the second grid that are under the cursor
+  def process_input_heuristic_remove_wall
+    # The mouse needs to be inside the grid, because we only want to remove walls
+    # the cursor is directly over
+    # Recalculations should only occur when a wall is actually deleted
+    if heuristic_mouse_over_grid?
+      if grid.walls.has_key?(heuristic_cell_closest_to_mouse)
+        grid.walls.delete(heuristic_cell_closest_to_mouse)
+        recalculate_searches
+      end
+    end
+  end
+  # Adds a wall in the first grid in the cell the mouse is over
+  def process_input_bfs_add_wall
+    if bfs_mouse_over_grid?
+      unless grid.walls.has_key?(bfs_cell_closest_to_mouse)
+        grid.walls[bfs_cell_closest_to_mouse] = true
+        recalculate_searches
+      end
+    end
+  end
 
-
-Advanced Rendering - Simple Render Targets - main.rb
-# ./samples/07_advanced_rendering/01_simple_render_targets/app/main.rb
-def tick args
-  # args.outputs.render_targets are really really powerful.
-  # They essentially allow you to create a sprite programmatically and cache the result.
+  # Adds a wall in the second grid in the cell the mouse is over
+  def process_input_heuristic_add_wall
+    if heuristic_mouse_over_grid?
+      unless grid.walls.has_key?(heuristic_cell_closest_to_mouse)
+        grid.walls[heuristic_cell_closest_to_mouse] = true
+        recalculate_searches
+      end
+    end
+  end
 
-  # Create a render_target of a :block and a :gradient on tick zero.
-  if args.state.tick_count == 0
-    args.render_target(:block).solids << [0, 0, 1280, 100]
+  # When the user grabs the star and puts their cursor to the far right
+  # and moves up and down, the star is supposed to move along the grid as well
+  # Finding the cell closest to the mouse helps with this
+  def bfs_cell_closest_to_mouse
+    # Closest cell to the mouse in the first grid
+    x = (inputs.mouse.point.x / grid.cell_size).to_i
+    y = (inputs.mouse.point.y / grid.cell_size).to_i
+    # Bound x and y to the grid
+    x = grid.width - 1 if x > grid.width - 1
+    y = grid.height - 1 if y > grid.height - 1
+    # Return closest cell
+    [x, y]
+  end
+
+  # When the user grabs the star and puts their cursor to the far right
+  # and moves up and down, the star is supposed to move along the grid as well
+  # Finding the cell closest to the mouse in the second grid helps with this
+  def heuristic_cell_closest_to_mouse
+    # Closest cell grid to the mouse in the second
+    x = (inputs.mouse.point.x / grid.cell_size).to_i
+    y = (inputs.mouse.point.y / grid.cell_size).to_i
+    # Translate the cell to the first grid
+    x -= grid.width + 1
+    # Bound x and y to the first grid
+    x = 0 if x < 0
+    y = 0 if y < 0
+    x = grid.width - 1 if x > grid.width - 1
+    y = grid.height - 1 if y > grid.height - 1
+    # Return closest cell
+    [x, y]
+  end
+
+  def recalculate_searches
+    # Reset the searches
+    bfs.came_from    = {}
+    bfs.frontier     = []
+    bfs.path         = []
+    heuristic.came_from = {}
+    heuristic.frontier  = []
+    heuristic.path      = []
+
+    # Move the searches forward to the current step
+    state.current_step.times { move_searches_one_step_forward }
+  end
+
+  def move_searches_one_step_forward
+    bfs_one_step_forward
+    heuristic_one_step_forward
+  end
+
+  def bfs_one_step_forward
+    return if bfs.came_from.has_key?(grid.target)
+
+    # Only runs at the beginning of the search as setup.
+    if bfs.came_from.empty?
+      bfs.frontier << grid.star
+      bfs.came_from[grid.star] = nil
+    end
+
+    # A step in the search
+    unless bfs.frontier.empty?
+      # Takes the next frontier cell
+      new_frontier = bfs.frontier.shift
+      # For each of its neighbors
+      adjacent_neighbors(new_frontier).each do |neighbor|
+        # That have not been visited and are not walls
+        unless bfs.came_from.has_key?(neighbor) || grid.walls.has_key?(neighbor)
+          # Add them to the frontier and mark them as visited
+          bfs.frontier << neighbor
+          bfs.came_from[neighbor] = new_frontier
+        end
+      end
+    end
 
-    # The gradient is actually just a collection of black solids with increasing
-    # opacities.
-    args.render_target(:gradient).solids << 90.map_with_index do |x|
-      50.map_with_index do |y|
-        [x * 15, y * 15, 15, 15, 0, 0, 0, (x * 3).fdiv(255) * 255]
+    # Sort the frontier so that cells that are in a zigzag pattern are prioritized over those in an line
+    # Comment this line and let a path generate to see the difference
+    bfs.frontier = bfs.frontier.sort_by {| cell | proximity_to_star(cell) }
+
+    # If the search found the target
+    if bfs.came_from.has_key?(grid.target)
+      # Calculate the path between the target and star
+      bfs_calc_path
+    end
+  end
+
+  # Calculates the path between the target and star for the breadth first search
+  # Only called when the breadth first search finds the target
+  def bfs_calc_path
+    # Start from the target
+    endpoint = grid.target
+    # And the cell it came from
+    next_endpoint = bfs.came_from[endpoint]
+    while endpoint and next_endpoint
+      # Draw a path between these two cells and store it
+      path = get_path_between(endpoint, next_endpoint)
+      bfs.path << path
+      # And get the next pair of cells
+      endpoint = next_endpoint
+      next_endpoint = bfs.came_from[endpoint]
+      # Continue till there are no more cells
+    end
+  end
+
+  # Moves the heuristic search forward one step
+  # Can be called from tick while the animation is playing
+  # Can also be called when recalculating the searches after the user edited the grid
+  def heuristic_one_step_forward
+    # Stop the search if the target has been found
+    return if heuristic.came_from.has_key?(grid.target)
+
+    # If the search has not begun
+    if heuristic.came_from.empty?
+      # Setup the search to begin from the star
+      heuristic.frontier << grid.star
+      heuristic.came_from[grid.star] = nil
+    end
+
+    # One step in the heuristic search
+
+    # Unless there are no more cells to explore from
+    unless heuristic.frontier.empty?
+      # Get the next cell to explore from
+      new_frontier = heuristic.frontier.shift
+      # For each of its neighbors
+      adjacent_neighbors(new_frontier).each do |neighbor|
+        # That have not been visited and are not walls
+        unless heuristic.came_from.has_key?(neighbor) || grid.walls.has_key?(neighbor)
+          # Add them to the frontier and mark them as visited
+          heuristic.frontier << neighbor
+          heuristic.came_from[neighbor] = new_frontier
+        end
       end
     end
+
+    # Sort the frontier so that cells that are in a zigzag pattern are prioritized over those in an line
+    heuristic.frontier = heuristic.frontier.sort_by {| cell | proximity_to_star(cell) }
+    # Sort the frontier so cells that are close to the target are then prioritized
+    heuristic.frontier = heuristic.frontier.sort_by {| cell | heuristic_heuristic(cell)  }
+
+    # If the search found the target
+    if heuristic.came_from.has_key?(grid.target)
+      # Calculate the path between the target and star
+      heuristic_calc_path
+    end
   end
 
-  # Take the :block render_target and present it horizontally centered.
-  # Use a subsection of the render_targetd specified by source_x,
-  # source_y, source_w, source_h.
-  args.outputs.sprites << { x: 0,
-                            y: 310,
-                            w: 1280,
-                            h: 100,
-                            path: :block,
-                            source_x: 0,
-                            source_y: 0,
-                            source_w: 1280,
-                            source_h: 100 }
+  # Returns one-dimensional absolute distance between cell and target
+  # Returns a number to compare distances between cells and the target
+  def heuristic_heuristic(cell)
+    (grid.target.x - cell.x).abs + (grid.target.y - cell.y).abs
+  end
 
-  # After rendering :block, render gradient on top of :block.
-  args.outputs.sprites << [0, 0, 1280, 720, :gradient]
+  # Calculates the path between the target and star for the heuristic search
+  # Only called when the heuristic search finds the target
+  def heuristic_calc_path
+    # Start from the target
+    endpoint = grid.target
+    # And the cell it came from
+    next_endpoint = heuristic.came_from[endpoint]
+    while endpoint and next_endpoint
+      # Draw a path between these two cells and store it
+      path = get_path_between(endpoint, next_endpoint)
+      heuristic.path << path
+      # And get the next pair of cells
+      endpoint = next_endpoint
+      next_endpoint = heuristic.came_from[endpoint]
+      # Continue till there are no more cells
+    end
+  end
 
-  args.outputs.labels  << [1270, 710, args.gtk.current_framerate, 0, 2, 255, 255, 255]
-  tick_instructions args, "Sample app shows how to use render_targets (programmatically create cached sprites)."
-end
+  # Returns a list of adjacent cells
+  # Used to determine what the next cells to be added to the frontier are
+  def adjacent_neighbors(cell)
+    neighbors = []
 
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
+    # Gets all the valid neighbors into the array
+    # From southern neighbor, clockwise
+    neighbors << [cell.x    , cell.y - 1] unless cell.y == 0
+    neighbors << [cell.x - 1, cell.y    ] unless cell.x == 0
+    neighbors << [cell.x    , cell.y + 1] unless cell.y == grid.height - 1
+    neighbors << [cell.x + 1, cell.y    ] unless cell.x == grid.width - 1
+
+    neighbors
   end
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
-end
+  # Finds the vertical and horizontal distance of a cell from the star
+  # and returns the larger value
+  # This method is used to have a zigzag pattern in the rendered path
+  # A cell that is [5, 5] from the star,
+  # is explored before over a cell that is [0, 7] away.
+  # So, if possible, the search tries to go diagonal (zigzag) first
+  def proximity_to_star(cell)
+    distance_x = (grid.star.x - cell.x).abs
+    distance_y = (grid.star.y - cell.y).abs
 
-$gtk.reset
+    if distance_x > distance_y
+      return distance_x
+    else
+      return distance_y
+    end
+  end
 
-
-Advanced Rendering - Render Targets With Tile Manipulation - main.rb
-# ./samples/07_advanced_rendering/02_render_targets_with_tile_manipulation/app/main.rb
-# This sample is meant to show you how to do that dripping transition thing
-#  at the start of the original Doom. Most of this file is here to animate
-#  a scene to wipe away; the actual wipe effect is in the last 20 lines or
-#  so.
+  # Methods that allow code to be more concise. Subdivides args.state, which is where all variables are stored.
+  def grid
+    state.grid
+  end
 
-$gtk.reset   # reset all game state if reloaded.
+  def buttons
+    state.buttons
+  end
 
-def circle_of_blocks pass, xoffset, yoffset, angleoffset, blocksize, distance
-  numblocks = 10
+  def slider
+    state.slider
+  end
 
-  for i in 1..numblocks do
-    angle = ((360 / numblocks) * i) + angleoffset
-    radians = angle * (Math::PI / 180)
-    x = (xoffset + (distance * Math.cos(radians))).round
-    y = (yoffset + (distance * Math.sin(radians))).round
-    pass.solids << [ x, y, blocksize, blocksize, 255, 255, 0 ]
+  def bfs
+    state.bfs
+  end
+
+  def heuristic
+    state.heuristic
+  end
+
+  # Descriptive aliases for colors
+  def default_color
+    [221, 212, 213] # Light Brown
+  end
+
+  def wall_color
+    [134, 134, 120] # Camo Green
+  end
+
+  def visited_color
+    [204, 191, 179] # Dark Brown
+  end
+
+  def frontier_color
+    [103, 136, 204] # Blue
+  end
+
+  def path_color
+    [231, 230, 228] # Pastel White
+  end
+
+  def button_color
+    [190, 190, 190] # Gray
   end
 end
+# Method that is called by DragonRuby periodically
+# Used for updating animations and calculations
+def tick args
 
-def draw_scene args, pass
-  pass.solids << [0, 360, 1280, 360, 0, 0, 200]
-  pass.solids << [0, 0, 1280, 360, 0, 127, 0]
+  # Pressing r will reset the application
+  if args.inputs.keyboard.key_down.r
+    args.gtk.reset
+    reset
+    return
+  end
 
-  blocksize = 100
-  angleoffset = args.state.tick_count * 2.5
-  centerx = (1280 - blocksize) / 2
-  centery = (720 - blocksize) / 2
+  # Every tick, new args are passed, and the Breadth First Search tick is called
+  $heuristic_with_walls ||= Heuristic_With_Walls.new(args)
+  $heuristic_with_walls.args = args
+  $heuristic_with_walls.tick
+end
 
-  circle_of_blocks pass, centerx, centery, angleoffset, blocksize * 2, 500
-  circle_of_blocks pass, centerx, centery, angleoffset, blocksize, 325
-  circle_of_blocks pass, centerx, centery, angleoffset, blocksize / 2, 200
-  circle_of_blocks pass, centerx, centery, angleoffset, blocksize / 4, 100
+
+def reset
+  $heuristic_with_walls = nil
 end
 
-def tick args
-  segments = 160
+
+Path Finding Algorithms - Heuristic With Walls - main.rb
+# ./samples/13_path_finding_algorithms/07_heuristic_with_walls/app/main.rb
+# This program is inspired by https://www.redblobgames.com/pathfinding/a-star/introduction.html
+# The effectiveness of the Heuristic search algorithm is shown through this demonstration.
+# Notice that both searches find the shortest path
+# The heuristic search, however, explores less of the grid, and is therefore faster.
+# The heuristic search prioritizes searching cells that are closer to the target.
+# Make sure to look at the Heuristic with walls program to see some of the downsides of the heuristic algorithm.
 
-  # On the first tick, initialize some stuff.
-  if !args.state.yoffsets
-    args.state.baseyoff = 0
-    args.state.yoffsets = []
-    for i in 0..segments do
-      args.state.yoffsets << rand * 100
+class Heuristic
+  attr_gtk
+
+  def tick
+    defaults
+    render
+    input
+    # If animation is playing, and max steps have not been reached
+    # Move the search a step forward
+    if state.play && state.current_step < state.max_steps
+      # Variable that tells the program what step to recalculate up to
+      state.current_step += 1
+      move_searches_one_step_forward
     end
   end
 
-  # Just draw some random stuff for a few seconds.
-  args.state.static_debounce ||= 60 * 2.5
-  if args.state.static_debounce > 0
-    last_frame = args.state.static_debounce == 1
-    target = last_frame ? args.render_target(:last_frame) : args.outputs
-    draw_scene args, target
-    args.state.static_debounce -= 1
-    return unless last_frame
+  def defaults
+    # Variables to edit the size and appearance of the grid
+    # Freely customizable to user's liking
+    grid.width     ||= 15
+    grid.height    ||= 15
+    grid.cell_size ||= 40
+    grid.rect      ||= [0, 0, grid.width, grid.height]
+
+    grid.star      ||= [0, 2]
+    grid.target    ||= [14, 12]
+    grid.walls     ||= {
+      [2, 2] => true,
+      [3, 2] => true,
+      [4, 2] => true,
+      [5, 2] => true,
+      [6, 2] => true,
+      [7, 2] => true,
+      [8, 2] => true,
+      [9, 2] => true,
+      [10, 2] => true,
+      [11, 2] => true,
+      [12, 2] => true,
+      [12, 3] => true,
+      [12, 4] => true,
+      [12, 5] => true,
+      [12, 6] => true,
+      [12, 7] => true,
+      [12, 8] => true,
+      [12, 9] => true,
+      [12, 10] => true,
+      [12, 11] => true,
+      [12, 12] => true,
+      [2, 12] => true,
+      [3, 12] => true,
+      [4, 12] => true,
+      [5, 12] => true,
+      [6, 12] => true,
+      [7, 12] => true,
+      [8, 12] => true,
+      [9, 12] => true,
+      [10, 12] => true,
+      [11, 12] => true,
+      [12, 12] => true
+    }
+    # There are no hills in the Heuristic Search Demo
+
+    # What the user is currently editing on the grid
+    # We store this value, because we want to remember the value even when
+    # the user's cursor is no longer over what they're interacting with, but
+    # they are still clicking down on the mouse.
+    state.user_input ||= :none
+
+    # These variables allow the breadth first search to take place
+    # Came_from is a hash with a key of a cell and a value of the cell that was expanded from to find the key.
+    # Used to prevent searching cells that have already been found
+    # and to trace a path from the target back to the starting point.
+    # Frontier is an array of cells to expand the search from.
+    # The search is over when there are no more cells to search from.
+    # Path stores the path from the target to the star, once the target has been found
+    # It prevents calculating the path every tick.
+    bfs.came_from  ||= {}
+    bfs.frontier   ||= []
+    bfs.path       ||= []
+
+    heuristic.came_from ||= {}
+    heuristic.frontier  ||= []
+    heuristic.path      ||= []
+
+    # Stores which step of the animation is being rendered
+    # When the user moves the star or messes with the walls,
+    # the searches are recalculated up to this step
+
+    # Unless the current step has a value
+    unless state.current_step
+      # Set the current step to 10
+      state.current_step = 10
+      # And calculate the searches up to step 10
+      recalculate_searches
+    end
+
+    # At some step the animation will end,
+    # and further steps won't change anything (the whole grid will be explored)
+    # This step is roughly the grid's width * height
+    # When anim_steps equals max_steps no more calculations will occur
+    # and the slider will be at the end
+    state.max_steps = grid.width * grid.height
+
+    # Whether the animation should play or not
+    # If true, every tick moves anim_steps forward one
+    # Pressing the stepwise animation buttons will pause the animation
+    # An if statement instead of the ||= operator is used for assigning a boolean value.
+    # The || operator does not differentiate between nil and false.
+    if state.play == nil
+      state.play = false
+    end
+
+    # Store the rects of the buttons that control the animation
+    # They are here for user customization
+    # Editing these might require recentering the text inside them
+    # Those values can be found in the render_button methods
+    buttons.left   = [470, 600, 50, 50]
+    buttons.center = [520, 600, 200, 50]
+    buttons.right  = [720, 600, 50, 50]
+
+    # The variables below are related to the slider
+    # They allow the user to customize them
+    # They also give a central location for the render and input methods to get
+    # information from
+    # x & y are the coordinates of the leftmost part of the slider line
+    slider.x = 440
+    slider.y = 675
+    # This is the width of the line
+    slider.w = 360
+    # This is the offset for the circle
+    # Allows the center of the circle to be on the line,
+    # as opposed to the upper right corner
+    slider.offset = 20
+    # This is the spacing between each of the notches on the slider
+    # Notches are places where the circle can rest on the slider line
+    # There needs to be a notch for each step before the maximum number of steps
+    slider.spacing = slider.w.to_f / state.max_steps.to_f
+  end
+
+  # All methods with render draw stuff on the screen
+  # UI has buttons, the slider, and labels
+  # The search specific rendering occurs in the respective methods
+  def render
+    render_ui
+    render_bfs
+    render_heuristic
   end
 
-  # build up the wipe...
+  def render_ui
+    render_buttons
+    render_slider
+    render_labels
+  end
 
-  # this is the thing we're wiping to.
-  args.outputs.sprites << [ 0, 0, 1280, 720, 'dragonruby.png' ]
+  def render_buttons
+    render_left_button
+    render_center_button
+    render_right_button
+  end
 
-  return if (args.state.baseyoff > (1280 + 100))  # stop when done sliding
+  def render_bfs
+    render_bfs_grid
+    render_bfs_star
+    render_bfs_target
+    render_bfs_visited
+    render_bfs_walls
+    render_bfs_frontier
+    render_bfs_path
+  end
 
-  segmentw = 1280 / segments
+  def render_heuristic
+    render_heuristic_grid
+    render_heuristic_star
+    render_heuristic_target
+    render_heuristic_visited
+    render_heuristic_walls
+    render_heuristic_frontier
+    render_heuristic_path
+  end
 
-  x = 0
-  for i in 0..segments do
-    yoffset = 0
-    if args.state.yoffsets[i] < args.state.baseyoff
-      yoffset = args.state.baseyoff - args.state.yoffsets[i]
-    end
+  # This method handles user input every tick
+  def input
+    # Check and handle button input
+    input_buttons
 
-    # (720 - yoffset) flips the coordinate system, (- 720) adjusts for the height of the segment.
-    args.outputs.sprites << [ x, (720 - yoffset) - 720, segmentw, 720, 'last_frame', 0, 255, 255, 255, 255, x, 0, segmentw, 720 ]
-    x += segmentw
-  end
+    # If the mouse was lifted this tick
+    if inputs.mouse.up
+      # Set current input to none
+      state.user_input = :none
+    end
 
-  args.state.baseyoff += 4
+    # If the mouse was clicked this tick
+    if inputs.mouse.down
+      # Determine what the user is editing and appropriately edit the state.user_input variable
+      determine_input
+    end
 
-  tick_instructions args, "Sample app shows an advanced usage of render_target."
-end
+    # Process user input based on user_input variable and current mouse position
+    process_input
+  end
 
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
+  # Determines what the user is editing
+  # This method is called when the mouse is clicked down
+  def determine_input
+    if mouse_over_slider?
+      state.user_input = :slider
+    # If the mouse is over the star in the first grid
+    elsif bfs_mouse_over_star?
+      # The user is editing the star from the first grid
+      state.user_input = :bfs_star
+    # If the mouse is over the star in the second grid
+    elsif heuristic_mouse_over_star?
+      # The user is editing the star from the second grid
+      state.user_input = :heuristic_star
+    # If the mouse is over the target in the first grid
+    elsif bfs_mouse_over_target?
+      # The user is editing the target from the first grid
+      state.user_input = :bfs_target
+    # If the mouse is over the target in the second grid
+    elsif heuristic_mouse_over_target?
+      # The user is editing the target from the second grid
+      state.user_input = :heuristic_target
+    # If the mouse is over a wall in the first grid
+    elsif bfs_mouse_over_wall?
+      # The user is removing a wall from the first grid
+      state.user_input = :bfs_remove_wall
+    # If the mouse is over a wall in the second grid
+    elsif heuristic_mouse_over_wall?
+      # The user is removing a wall from the second grid
+      state.user_input = :heuristic_remove_wall
+    # If the mouse is over the first grid
+    elsif bfs_mouse_over_grid?
+      # The user is adding a wall from the first grid
+      state.user_input = :bfs_add_wall
+    # If the mouse is over the second grid
+    elsif heuristic_mouse_over_grid?
+      # The user is adding a wall from the second grid
+      state.user_input = :heuristic_add_wall
+    end
+  end
+
+  # Processes click and drag based on what the user is currently dragging
+  def process_input
+    if state.user_input == :slider
+      process_input_slider
+    elsif state.user_input == :bfs_star
+      process_input_bfs_star
+    elsif state.user_input == :heuristic_star
+      process_input_heuristic_star
+    elsif state.user_input == :bfs_target
+      process_input_bfs_target
+    elsif state.user_input == :heuristic_target
+      process_input_heuristic_target
+    elsif state.user_input == :bfs_remove_wall
+      process_input_bfs_remove_wall
+    elsif state.user_input == :heuristic_remove_wall
+      process_input_heuristic_remove_wall
+    elsif state.user_input == :bfs_add_wall
+      process_input_bfs_add_wall
+    elsif state.user_input == :heuristic_add_wall
+      process_input_heuristic_add_wall
+    end
   end
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
-end
+  def render_slider
+    # Using primitives hides the line under the white circle of the slider
+    # Draws the line
+    outputs.primitives << [slider.x, slider.y, slider.x + slider.w, slider.y].line
+    # The circle needs to be offset so that the center of the circle
+    # overlaps the line instead of the upper right corner of the circle
+    # The circle's x value is also moved based on the current seach step
+    circle_x = (slider.x - slider.offset) + (state.current_step * slider.spacing)
+    circle_y = (slider.y - slider.offset)
+    circle_rect = [circle_x, circle_y, 37, 37]
+    outputs.primitives << [circle_rect, 'circle-white.png'].sprite
+  end
 
-

-Advanced Rendering - Render Target Viewports - main.rb
-# ./samples/07_advanced_rendering/03_render_target_viewports/app/main.rb
-=begin
+  def render_labels
+    outputs.labels << [205, 625, "Breadth First Search"]
+    outputs.labels << [820, 625, "Heuristic Best-First Search"]
+  end
 
- APIs listing that haven't been encountered in previous sample apps:
+  def render_left_button
+    # Draws the button_color button, and a black border
+    # The border separates the buttons visually
+    outputs.solids  << [buttons.left, button_color]
+    outputs.borders << [buttons.left]
 
- - args.state.new_entity: Used when we want to create a new object, like a sprite or button.
-   For example, if we want to create a new button, we would declare it as a new entity and
-   then define its properties. (Remember, you can use state to define ANY property and it will
-   be retained across frames.)
+    # Renders an explanatory label in the center of the button
+    # Explains to the user what the button does
+    # If the button size is changed, the label might need to be edited as well
+    # to keep the label in the center of the button
+    label_x = buttons.left.x + 20
+    label_y = buttons.left.y + 35
+    outputs.labels  << [label_x, label_y, "<"]
+  end
 
-   If you have a solar system and you're creating args.state.sun and setting its image path to an
-   image in the sprites folder, you would do the following:
-   (See samples/99_sample_nddnug_workshop for more details.)
+  def render_center_button
+    # Draws the button_color button, and a black border
+    # The border separates the buttons visually
+    outputs.solids  << [buttons.center, button_color]
+    outputs.borders << [buttons.center]
 
-   args.state.sun ||= args.state.new_entity(:sun) do |s|
-   s.path = 'sprites/sun.png'
-   end
+    # Renders an explanatory label in the center of the button
+    # Explains to the user what the button does
+    # If the button size is changed, the label might need to be edited as well
+    # to keep the label in the center of the button
+    label_x    = buttons.center.x + 37
+    label_y    = buttons.center.y + 35
+    label_text = state.play ? "Pause Animation" : "Play Animation"
+    outputs.labels << [label_x, label_y, label_text]
+  end
 
- - String interpolation: Uses #{} syntax; everything between the #{ and the } is evaluated
-   as Ruby code, and the placeholder is replaced with its corresponding value or result.
+  def render_right_button
+    # Draws the button_color button, and a black border
+    # The border separates the buttons visually
+    outputs.solids  << [buttons.right, button_color]
+    outputs.borders << [buttons.right]
 
-   For example, if we have a variable
-   name = "Ruby"
-   then the line
-   puts "How are you, #{name}?"
-   would print "How are you, Ruby?" to the console.
-   (Remember, string interpolation only works with double quotes!)
+    # Renders an explanatory label in the center of the button
+    # Explains to the user what the button does
+    label_x = buttons.right.x + 20
+    label_y = buttons.right.y + 35
+    outputs.labels  << [label_x, label_y, ">"]
+  end
 
- - Ternary operator (?): Similar to if statement; first evalulates whether a statement is
-   true or false, and then executes a command depending on that result.
-   For example, if we had a variable
-   grade = 75
-   and used the ternary operator in the command
-   pass_or_fail = grade > 65 ? "pass" : "fail"
-   then the value of pass_or_fail would be "pass" since grade's value was greater than 65.
+  def render_bfs_grid
+    # A large rect the size of the grid
+    outputs.solids << [bfs_scale_up(grid.rect), default_color]
 
- Reminders:
+    # The vertical grid lines
+    for x in 0..grid.width
+      outputs.lines << bfs_vertical_line(x)
+    end
 
- - args.grid.(left|right|top|bottom): Pixel value for the boundaries of the virtual
-   720 p screen (Dragon Ruby Game Toolkits's virtual resolution is always 1280x720).
+    # The horizontal grid lines
+    for y in 0..grid.height
+      outputs.lines << bfs_horizontal_line(y)
+    end
+  end
 
- - Numeric#shift_(left|right|up|down): Shifts the Numeric in the correct direction
-   by adding or subracting.
+  def render_heuristic_grid
+    # A large rect the size of the grid
+    outputs.solids << [heuristic_scale_up(grid.rect), default_color]
 
- - ARRAY#inside_rect?: An array with at least two values is considered a point. An array
-   with at least four values is considered a rect. The inside_rect? function returns true
-   or false depending on if the point is inside the rect.
+    # The vertical grid lines
+    for x in 0..grid.width
+      outputs.lines << heuristic_vertical_line(x)
+    end
 
- - ARRAY#intersect_rect?: Returns true or false depending on if the two rectangles intersect.
+    # The horizontal grid lines
+    for y in 0..grid.height
+      outputs.lines << heuristic_horizontal_line(y)
+    end
+  end
 
- - args.inputs.mouse.click: This property will be set if the mouse was clicked.
-   For more information about the mouse, go to mygame/documentation/07-mouse.md.
+  # Returns a vertical line for a column of the first grid
+  def bfs_vertical_line column
+    bfs_scale_up([column, 0, column, grid.height])
+  end
 
- - args.inputs.keyboard.key_up.KEY: The value of the properties will be set
-   to the frame  that the key_up event occurred (the frame correlates
-   to args.state.tick_count).
-   For more information about the keyboard, go to mygame/documentation/06-keyboard.md.
+  # Returns a horizontal line for a column of the first grid
+  def bfs_horizontal_line row
+    bfs_scale_up([0, row, grid.width, row])
+  end
 
- - args.state.labels:
-   The parameters for a label are
-   1. the position (x, y)
-   2. the text
-   3. the size
-   4. the alignment
-   5. the color (red, green, and blue saturations)
-   6. the alpha (or transparency)
-   For more information about labels, go to mygame/documentation/02-labels.md.
+  # Returns a vertical line for a column of the second grid
+  def heuristic_vertical_line column
+    bfs_scale_up([column + grid.width + 1, 0, column + grid.width + 1, grid.height])
+  end
 
- - args.state.lines:
-   The parameters for a line are
-   1. the starting position (x, y)
-   2. the ending position (x2, y2)
-   3. the color (red, green, and blue saturations)
-   4. the alpha (or transparency)
-   For more information about lines, go to mygame/documentation/04-lines.md.
+  # Returns a horizontal line for a column of the second grid
+  def heuristic_horizontal_line row
+    bfs_scale_up([grid.width + 1, row, grid.width + grid.width + 1, row])
+  end
 
- - args.state.solids (and args.state.borders):
-   The parameters for a solid (or border) are
-   1. the position (x, y)
-   2. the width (w)
-   3. the height (h)
-   4. the color (r, g, b)
-   5. the alpha (or transparency)
-   For more information about solids and borders, go to mygame/documentation/03-solids-and-borders.md.
+  # Renders the star on the first grid
+  def render_bfs_star
+    outputs.sprites << [bfs_scale_up(grid.star), 'star.png']
+  end
 
- - args.state.sprites:
-   The parameters for a sprite are
-   1. the position (x, y)
-   2. the width (w)
-   3. the height (h)
-   4. the image path
-   5. the angle
-   6. the alpha (or transparency)
-   For more information about sprites, go to mygame/documentation/05-sprites.md.
-=end
+  # Renders the star on the second grid
+  def render_heuristic_star
+    outputs.sprites << [heuristic_scale_up(grid.star), 'star.png']
+  end
 
-# This sample app shows different objects that can be used when making games, such as labels,
-# lines, sprites, solids, buttons, etc. Each demo section shows how these objects can be used.
+  # Renders the target on the first grid
+  def render_bfs_target
+    outputs.sprites << [bfs_scale_up(grid.target), 'target.png']
+  end
 
-# Also note that state.tick_count refers to the passage of time, or current frame.
+  # Renders the target on the second grid
+  def render_heuristic_target
+    outputs.sprites << [heuristic_scale_up(grid.target), 'target.png']
+  end
 
-class TechDemo
-  attr_accessor :inputs, :state, :outputs, :grid, :args
+  # Renders the walls on the first grid
+  def render_bfs_walls
+    grid.walls.each_key do | wall |
+      outputs.solids << [bfs_scale_up(wall), wall_color]
+    end
+  end
 
-  # Calls all methods necessary for the app to run properly.
-  def tick
-    labels_tech_demo
-    lines_tech_demo
-    solids_tech_demo
-    borders_tech_demo
-    sprites_tech_demo
-    keyboards_tech_demo
-    controller_tech_demo
-    mouse_tech_demo
-    point_to_rect_tech_demo
-    rect_to_rect_tech_demo
-    button_tech_demo
-    export_game_state_demo
-    window_state_demo
-    render_seperators
+  # Renders the walls on the second grid
+  def render_heuristic_walls
+    grid.walls.each_key do | wall |
+      outputs.solids << [heuristic_scale_up(wall), wall_color]
+    end
   end
 
-  # Shows output of different kinds of labels on the screen
-  def labels_tech_demo
-    outputs.labels << [grid.left.shift_right(5), grid.top.shift_down(5), "This is a label located at the top left."]
-    outputs.labels << [grid.left.shift_right(5), grid.bottom.shift_up(30), "This is a label located at the bottom left."]
-    outputs.labels << [ 5, 690, "Labels (x, y, text, size, align, r, g, b, a)"]
-    outputs.labels << [ 5, 660, "Smaller label.",  -2]
-    outputs.labels << [ 5, 630, "Small label.",    -1]
-    outputs.labels << [ 5, 600, "Medium label.",    0]
-    outputs.labels << [ 5, 570, "Large label.",     1]
-    outputs.labels << [ 5, 540, "Larger label.",    2]
-    outputs.labels << [300, 660, "Left aligned.",    0, 2]
-    outputs.labels << [300, 640, "Center aligned.",  0, 1]
-    outputs.labels << [300, 620, "Right aligned.",   0, 0]
-    outputs.labels << [175, 595, "Red Label.",       0, 0, 255,   0,   0]
-    outputs.labels << [175, 575, "Green Label.",     0, 0,   0, 255,   0]
-    outputs.labels << [175, 555, "Blue Label.",      0, 0,   0,   0, 255]
-    outputs.labels << [175, 535, "Faded Label.",     0, 0,   0,   0,   0, 128]
+  # Renders the visited cells on the first grid
+  def render_bfs_visited
+    bfs.came_from.each_key do | visited_cell |
+      outputs.solids << [bfs_scale_up(visited_cell), visited_color]
+    end
   end
 
-  # Shows output of lines on the screen
-  def lines_tech_demo
-    outputs.labels << [5, 500, "Lines (x, y, x2, y2, r, g, b, a)"]
-    outputs.lines  << [5, 450, 100, 450]
-    outputs.lines  << [5, 430, 300, 430]
-    outputs.lines  << [5, 410, 300, 410, state.tick_count % 255, 0, 0, 255] # red saturation changes
-    outputs.lines  << [5, 390 - state.tick_count % 25, 300, 390, 0, 0, 0, 255] # y position changes
-    outputs.lines  << [5 + state.tick_count % 200, 360, 300, 360, 0, 0, 0, 255] # x position changes
+  # Renders the visited cells on the second grid
+  def render_heuristic_visited
+    heuristic.came_from.each_key do | visited_cell |
+      outputs.solids << [heuristic_scale_up(visited_cell), visited_color]
+    end
   end
 
-  # Shows output of different kinds of solids on the screen
-  def solids_tech_demo
-    outputs.labels << [  5, 350, "Solids (x, y, w, h, r, g, b, a)"]
-    outputs.solids << [ 10, 270, 50, 50]
-    outputs.solids << [ 70, 270, 50, 50, 0, 0, 0]
-    outputs.solids << [130, 270, 50, 50, 255, 0, 0]
-    outputs.solids << [190, 270, 50, 50, 255, 0, 0, 128]
-    outputs.solids << [250, 270, 50, 50, 0, 0, 0, 128 + state.tick_count % 128] # transparency changes
+  # Renders the frontier cells on the first grid
+  def render_bfs_frontier
+    bfs.frontier.each do | frontier_cell |
+      outputs.solids << [bfs_scale_up(frontier_cell), frontier_color, 200]
+    end
   end
 
-  # Shows output of different kinds of borders on the screen
-  # The parameters for a border are the same as the parameters for a solid
-  def borders_tech_demo
-    outputs.labels <<  [  5, 260, "Borders (x, y, w, h, r, g, b, a)"]
-    outputs.borders << [ 10, 180, 50, 50]
-    outputs.borders << [ 70, 180, 50, 50, 0, 0, 0]
-    outputs.borders << [130, 180, 50, 50, 255, 0, 0]
-    outputs.borders << [190, 180, 50, 50, 255, 0, 0, 128]
-    outputs.borders << [250, 180, 50, 50, 0, 0, 0, 128 + state.tick_count % 128] # transparency changes
+  # Renders the frontier cells on the second grid
+  def render_heuristic_frontier
+    heuristic.frontier.each do | frontier_cell |
+      outputs.solids << [heuristic_scale_up(frontier_cell), frontier_color, 200]
+    end
   end
 
-  # Shows output of different kinds of sprites on the screen
-  def sprites_tech_demo
-    outputs.labels <<  [   5, 170, "Sprites (x, y, w, h, path, angle, a)"]
-    outputs.sprites << [  10, 40, 128, 101, 'dragonruby.png']
-    outputs.sprites << [ 150, 40, 128, 101, 'dragonruby.png', state.tick_count % 360] # angle changes
-    outputs.sprites << [ 300, 40, 128, 101, 'dragonruby.png', 0, state.tick_count % 255] # transparency changes
+  # Renders the path found by the breadth first search on the first grid
+  def render_bfs_path
+    bfs.path.each do | path |
+      outputs.solids << [bfs_scale_up(path), path_color]
+    end
   end
 
-  # Holds size, alignment, color (black), and alpha (transparency) parameters
-  # Using small_font as a parameter accounts for all remaining parameters
-  # so they don't have to be repeatedly typed
-  def small_font
-    [-2, 0, 0, 0, 0, 255]
+  # Renders the path found by the heuristic search on the second grid
+  def render_heuristic_path
+    heuristic.path.each do | path |
+      outputs.solids << [heuristic_scale_up(path), path_color]
+    end
   end
 
-  # Sets position of each row
-  # Converts given row value to pixels that DragonRuby understands
-  def row_to_px row_number
+  # Returns the rect for the path between two cells based on their relative positions
+  def get_path_between(cell_one, cell_two)
+    path = []
 
-    # Row 0 starts 5 units below the top of the grid.
-    # Each row afterward is 20 units lower.
-    grid.top.shift_down(5).shift_down(20 * row_number)
+    # If cell one is above cell two
+    if cell_one.x == cell_two.x and cell_one.y > cell_two.y
+      # Path starts from the center of cell two and moves upward to the center of cell one
+      path = [cell_two.x + 0.3, cell_two.y + 0.3, 0.4, 1.4]
+    # If cell one is below cell two
+    elsif cell_one.x == cell_two.x and cell_one.y < cell_two.y
+      # Path starts from the center of cell one and moves upward to the center of cell two
+      path = [cell_one.x + 0.3, cell_one.y + 0.3, 0.4, 1.4]
+    # If cell one is to the left of cell two
+    elsif cell_one.x > cell_two.x and cell_one.y == cell_two.y
+      # Path starts from the center of cell two and moves rightward to the center of cell one
+      path = [cell_two.x + 0.3, cell_two.y + 0.3, 1.4, 0.4]
+    # If cell one is to the right of cell two
+    elsif cell_one.x < cell_two.x and cell_one.y == cell_two.y
+      # Path starts from the center of cell one and moves rightward to the center of cell two
+      path = [cell_one.x + 0.3, cell_one.y + 0.3, 1.4, 0.4]
+    end
+
+    path
   end
 
-  # Uses labels to output current game time (passage of time), and whether or not "h" was pressed
-  # If "h" is pressed, the frame is output when the key_up event occurred
-  def keyboards_tech_demo
-    outputs.labels << [460, row_to_px(0), "Current game time: #{state.tick_count}", small_font]
-    outputs.labels << [460, row_to_px(2), "Keyboard input: inputs.keyboard.key_up.h", small_font]
-    outputs.labels << [460, row_to_px(3), "Press \"h\" on the keyboard.", small_font]
+  # In code, the cells are represented as 1x1 rectangles
+  # When drawn, the cells are larger than 1x1 rectangles
+  # This method is used to scale up cells, and lines
+  # Objects are scaled up according to the grid.cell_size variable
+  # This allows for easy customization of the visual scale of the grid
+  # This method scales up cells for the first grid
+  def bfs_scale_up(cell)
+    # Prevents the original value of cell from being edited
+    cell = cell.clone
 
-    if inputs.keyboard.key_up.h # if "h" key_up event occurs
-      state.h_pressed_at = state.tick_count # frame it occurred is stored
+    # If cell is just an x and y coordinate
+    if cell.size == 2
+      # Add a width and height of 1
+      cell << 1
+      cell << 1
     end
 
-    # h_pressed_at is initially set to false, and changes once the user presses the "h" key.
-    state.h_pressed_at ||= false
+    # Scale all the values up
+    cell.map! { |value| value * grid.cell_size }
 
-    if state.h_pressed_at # if h is pressed (pressed_at has a frame number and is no longer false)
-      outputs.labels << [460, row_to_px(4), "\"h\" was pressed at time: #{state.h_pressed_at}", small_font]
-    else # otherwise, label says "h" was never pressed
-      outputs.labels << [460, row_to_px(4), "\"h\" has never been pressed.", small_font]
-    end
+    # Returns the scaled up cell
+    cell
+  end
 
-    # border around keyboard input demo section
-    outputs.borders << [455, row_to_px(5), 360, row_to_px(2).shift_up(5) - row_to_px(5)]
+  # Translates the given cell grid.width + 1 to the right and then scales up
+  # Used to draw cells for the second grid
+  # This method does not work for lines,
+  # so separate methods exist for the grid lines
+  def heuristic_scale_up(cell)
+    # Prevents the original value of cell from being edited
+    cell = cell.clone
+    # Translates the cell to the second grid equivalent
+    cell.x += grid.width + 1
+    # Proceeds as if scaling up for the first grid
+    bfs_scale_up(cell)
   end
 
-  # Sets definition for a small label
-  # Makes it easier to position labels in respect to the position of other labels
-  def small_label x, row, message
-    [x, row_to_px(row), message, small_font]
+  # Checks and handles input for the buttons
+  # Called when the mouse is lifted
+  def input_buttons
+    input_left_button
+    input_center_button
+    input_right_button
   end
 
-  # Uses small labels to show whether the "a" button on the controller is down, held, or up.
-  # y value of each small label is set by calling the row_to_px method
-  def controller_tech_demo
-    x = 460
-    outputs.labels << small_label(x, 6, "Controller one input: inputs.controller_one")
-    outputs.labels << small_label(x, 7, "Current state of the \"a\" button.")
-    outputs.labels << small_label(x, 8, "Check console window for more info.")
+  # Checks if the previous step button is clicked
+  # If it is, it pauses the animation and moves the search one step backward
+  def input_left_button
+    if left_button_clicked?
+      state.play = false
+      state.current_step -= 1
+      recalculate_searches
+    end
+  end
 
-    if inputs.controller_one.key_down.a # if "a" is in "down" state
-      outputs.labels << small_label(x, 9, "\"a\" button down: #{inputs.controller_one.key_down.a}")
-      puts "\"a\" button down at #{inputs.controller_one.key_down.a}" # prints frame the event occurred
-    elsif inputs.controller_one.key_held.a # if "a" is held down
-      outputs.labels << small_label(x, 9, "\"a\" button held: #{inputs.controller_one.key_held.a}")
-    elsif inputs.controller_one.key_up.a # if "a" is in up state
-      outputs.labels << small_label(x, 9, "\"a\" button up: #{inputs.controller_one.key_up.a}")
-      puts "\"a\" key up at #{inputs.controller_one.key_up.a}"
-    else # if no event has occurred
-      outputs.labels << small_label(x, 9, "\"a\" button state is nil.")
+  # Controls the play/pause button
+  # Inverses whether the animation is playing or not when clicked
+  def input_center_button
+    if center_button_clicked? || inputs.keyboard.key_down.space
+      state.play = !state.play
+    end
+  end
+
+  # Checks if the next step button is clicked
+  # If it is, it pauses the animation and moves the search one step forward
+  def input_right_button
+    if right_button_clicked?
+      state.play = false
+      state.current_step += 1
+      move_searches_one_step_forward
     end
+  end
+
+  # These methods detect when the buttons are clicked
+  def left_button_clicked?
+    inputs.mouse.point.inside_rect?(buttons.left) && inputs.mouse.up
+  end
+
+  def center_button_clicked?
+    inputs.mouse.point.inside_rect?(buttons.center) && inputs.mouse.up
+  end
+
+  def right_button_clicked?
+    inputs.mouse.point.inside_rect?(buttons.right) && inputs.mouse.up
+  end
 
-    # border around controller input demo section
-    outputs.borders << [455, row_to_px(10), 360, row_to_px(6).shift_up(5) - row_to_px(10)]
+
+  # Signal that the user is going to be moving the slider
+  # Is the mouse over the circle of the slider?
+  def mouse_over_slider?
+    circle_x = (slider.x - slider.offset) + (state.current_step * slider.spacing)
+    circle_y = (slider.y - slider.offset)
+    circle_rect = [circle_x, circle_y, 37, 37]
+    inputs.mouse.point.inside_rect?(circle_rect)
   end
 
-  # Outputs when the mouse was clicked, as well as the coordinates on the screen
-  # of where the click occurred
-  def mouse_tech_demo
-    x = 460
+  # Signal that the user is going to be moving the star from the first grid
+  def bfs_mouse_over_star?
+    inputs.mouse.point.inside_rect?(bfs_scale_up(grid.star))
+  end
 
-    outputs.labels << small_label(x, 11, "Mouse input: inputs.mouse")
+  # Signal that the user is going to be moving the star from the second grid
+  def heuristic_mouse_over_star?
+    inputs.mouse.point.inside_rect?(heuristic_scale_up(grid.star))
+  end
 
-    if inputs.mouse.click # if click has a value and is not nil
-      state.last_mouse_click = inputs.mouse.click # coordinates of click are stored
+  # Signal that the user is going to be moving the target from the first grid
+  def bfs_mouse_over_target?
+    inputs.mouse.point.inside_rect?(bfs_scale_up(grid.target))
+  end
+
+  # Signal that the user is going to be moving the target from the second grid
+  def heuristic_mouse_over_target?
+    inputs.mouse.point.inside_rect?(heuristic_scale_up(grid.target))
+  end
+
+  # Signal that the user is going to be removing walls from the first grid
+  def bfs_mouse_over_wall?
+    grid.walls.each_key do | wall |
+      return true if inputs.mouse.point.inside_rect?(bfs_scale_up(wall))
     end
 
-    if state.last_mouse_click # if mouse is clicked (has coordinates as value)
-      # outputs the time (frame) the click occurred, as well as how many frames have passed since the event
-      outputs.labels << small_label(x, 12, "Mouse click happened at: #{state.last_mouse_click.created_at}, #{state.last_mouse_click.created_at_elapsed}")
-      # outputs coordinates of click
-      outputs.labels << small_label(x, 13, "Mouse click location: #{state.last_mouse_click.point.x}, #{state.last_mouse_click.point.y}")
-    else # otherwise if the mouse has not been clicked
-      outputs.labels << small_label(x, 12, "Mouse click has not occurred yet.")
-      outputs.labels << small_label(x, 13, "Please click mouse.")
+    false
+  end
+
+  # Signal that the user is going to be removing walls from the second grid
+  def heuristic_mouse_over_wall?
+    grid.walls.each_key do | wall |
+      return true if inputs.mouse.point.inside_rect?(heuristic_scale_up(wall))
     end
+
+    false
   end
 
-  # Outputs whether a mouse click occurred inside or outside of a box
-  def point_to_rect_tech_demo
-    x = 460
+  # Signal that the user is going to be adding walls from the first grid
+  def bfs_mouse_over_grid?
+    inputs.mouse.point.inside_rect?(bfs_scale_up(grid.rect))
+  end
 
-    outputs.labels << small_label(x, 15, "Click inside the blue box maybe ---->")
+  # Signal that the user is going to be adding walls from the second grid
+  def heuristic_mouse_over_grid?
+    inputs.mouse.point.inside_rect?(heuristic_scale_up(grid.rect))
+  end
 
-    box = [765, 370, 50, 50, 0, 0, 170] # blue box
-    outputs.borders << box
+  # This method is called when the user is editing the slider
+  # It pauses the animation and moves the white circle to the closest integer point
+  # on the slider
+  # Changes the step of the search to be animated
+  def process_input_slider
+    state.play = false
+    mouse_x = inputs.mouse.point.x
 
-    if state.last_mouse_click # if the mouse was clicked
-      if state.last_mouse_click.point.inside_rect? box # if mouse clicked inside box
-        outputs.labels << small_label(x, 16, "Mouse click happened inside the box.")
-      else # otherwise, if mouse was clicked outside the box
-        outputs.labels << small_label(x, 16, "Mouse click happened outside the box.")
-      end
-    else # otherwise, if was not clicked at all
-      outputs.labels << small_label(x, 16, "Mouse click has not occurred yet.") # output if the mouse was not clicked
-    end
+    # Bounds the mouse_x to the closest x value on the slider line
+    mouse_x = slider.x if mouse_x < slider.x
+    mouse_x = slider.x + slider.w if mouse_x > slider.x + slider.w
 
-    # border around mouse input demo section
-    outputs.borders << [455, row_to_px(14), 360, row_to_px(11).shift_up(5) - row_to_px(14)]
-  end
+    # Sets the current search step to the one represented by the mouse x value
+    # The slider's circle moves due to the render_slider method using anim_steps
+    state.current_step = ((mouse_x - slider.x) / slider.spacing).to_i
 
-  # Outputs a red box onto the screen. A mouse click from the user inside of the red box will output
-  # a smaller box. If two small boxes are inside of the red box, it will be determined whether or not
-  # they intersect.
-  def rect_to_rect_tech_demo
-    x = 460
+    recalculate_searches
+  end
 
-    outputs.labels << small_label(x, 17.5, "Click inside the red box below.") # label with instructions
-    red_box = [460, 250, 355, 90, 170, 0, 0] # definition of the red box
-    outputs.borders << red_box # output as a border (not filled in)
+  # Moves the star to the cell closest to the mouse in the first grid
+  # Only resets the search if the star changes position
+  # Called whenever the user is editing the star (puts mouse down on star)
+  def process_input_bfs_star
+    old_star = grid.star.clone
+    unless bfs_cell_closest_to_mouse == grid.target
+      grid.star = bfs_cell_closest_to_mouse
+    end
+    unless old_star == grid.star
+      recalculate_searches
+    end
+  end
 
-    # If the mouse is clicked inside the red box, two collision boxes are created.
-    if inputs.mouse.click
-      if inputs.mouse.click.point.inside_rect? red_box
-        if !state.box_collision_one # if the collision_one box does not yet have a definition
-          # Subtracts 25 from the x and y positions of the click point in order to make the click point the center of the box.
-          # You can try deleting the subtraction to see how it impacts the box placement.
-          state.box_collision_one = [inputs.mouse.click.point.x - 25, inputs.mouse.click.point.y - 25, 50, 50, 180, 0,   0, 180]  # sets definition
-        elsif !state.box_collision_two # if collision_two does not yet have a definition
-          state.box_collision_two = [inputs.mouse.click.point.x - 25, inputs.mouse.click.point.y - 25, 50, 50,   0, 0, 180, 180] # sets definition
-        else
-          state.box_collision_one = nil # both boxes are empty
-          state.box_collision_two = nil
-        end
-      end
+  # Moves the star to the cell closest to the mouse in the second grid
+  # Only resets the search if the star changes position
+  # Called whenever the user is editing the star (puts mouse down on star)
+  def process_input_heuristic_star
+    old_star = grid.star.clone
+    unless heuristic_cell_closest_to_mouse == grid.target
+      grid.star = heuristic_cell_closest_to_mouse
+    end
+    unless old_star == grid.star
+      recalculate_searches
     end
+  end
 
-    # If collision boxes exist, they are output onto screen inside the red box as solids
-    if state.box_collision_one
-      outputs.solids << state.box_collision_one
+  # Moves the target to the grid closest to the mouse in the first grid
+  # Only recalculate_searchess the search if the target changes position
+  # Called whenever the user is editing the target (puts mouse down on target)
+  def process_input_bfs_target
+    old_target = grid.target.clone
+    unless bfs_cell_closest_to_mouse == grid.star
+      grid.target = bfs_cell_closest_to_mouse
     end
+    unless old_target == grid.target
+      recalculate_searches
+    end
+  end
 
-    if state.box_collision_two
-      outputs.solids << state.box_collision_two
+  # Moves the target to the cell closest to the mouse in the second grid
+  # Only recalculate_searchess the search if the target changes position
+  # Called whenever the user is editing the target (puts mouse down on target)
+  def process_input_heuristic_target
+    old_target = grid.target.clone
+    unless heuristic_cell_closest_to_mouse == grid.star
+      grid.target = heuristic_cell_closest_to_mouse
     end
+    unless old_target == grid.target
+      recalculate_searches
+    end
+  end
 
-    # Outputs whether or not the two collision boxes intersect.
-    if state.box_collision_one && state.box_collision_two # if both collision_boxes are defined (and not nil or empty)
-      if state.box_collision_one.intersect_rect? state.box_collision_two # if the two boxes intersect
-        outputs.labels << small_label(x, 23.5, 'The boxes intersect.')
-      else # otherwise, if the two boxes do not intersect
-        outputs.labels << small_label(x, 23.5, 'The boxes do not intersect.')
+  # Removes walls in the first grid that are under the cursor
+  def process_input_bfs_remove_wall
+    # The mouse needs to be inside the grid, because we only want to remove walls
+    # the cursor is directly over
+    # Recalculations should only occur when a wall is actually deleted
+    if bfs_mouse_over_grid?
+      if grid.walls.has_key?(bfs_cell_closest_to_mouse)
+        grid.walls.delete(bfs_cell_closest_to_mouse)
+        recalculate_searches
       end
-    else
-      outputs.labels << small_label(x, 23.5, '--') # if the two boxes are not defined (are nil or empty), this label is output
     end
   end
 
-  # Creates a button and outputs it onto the screen using labels and borders.
-  # If the button is clicked, the color changes to make it look faded.
-  def button_tech_demo
-    x, y, w, h = 460, 160, 300, 50
-    state.button        ||= state.new_entity(:button_with_fade)
+  # Removes walls in the second grid that are under the cursor
+  def process_input_heuristic_remove_wall
+    # The mouse needs to be inside the grid, because we only want to remove walls
+    # the cursor is directly over
+    # Recalculations should only occur when a wall is actually deleted
+    if heuristic_mouse_over_grid?
+      if grid.walls.has_key?(heuristic_cell_closest_to_mouse)
+        grid.walls.delete(heuristic_cell_closest_to_mouse)
+        recalculate_searches
+      end
+    end
+  end
+  # Adds a wall in the first grid in the cell the mouse is over
+  def process_input_bfs_add_wall
+    if bfs_mouse_over_grid?
+      unless grid.walls.has_key?(bfs_cell_closest_to_mouse)
+        grid.walls[bfs_cell_closest_to_mouse] = true
+        recalculate_searches
+      end
+    end
+  end
 
-    # Adds w.half to x and h.half + 10 to y in order to display the text inside the button's borders.
-    state.button.label  ||= [x + w.half, y + h.half + 10, "click me and watch me fade", 0, 1]
-    state.button.border ||= [x, y, w, h]
+  # Adds a wall in the second grid in the cell the mouse is over
+  def process_input_heuristic_add_wall
+    if heuristic_mouse_over_grid?
+      unless grid.walls.has_key?(heuristic_cell_closest_to_mouse)
+        grid.walls[heuristic_cell_closest_to_mouse] = true
+        recalculate_searches
+      end
+    end
+  end
 
-    if inputs.mouse.click && inputs.mouse.click.point.inside_rect?(state.button.border) # if mouse is clicked, and clicked inside button's border
-      state.button.clicked_at = inputs.mouse.click.created_at # stores the time the click occurred
+  # When the user grabs the star and puts their cursor to the far right
+  # and moves up and down, the star is supposed to move along the grid as well
+  # Finding the cell closest to the mouse helps with this
+  def bfs_cell_closest_to_mouse
+    # Closest cell to the mouse in the first grid
+    x = (inputs.mouse.point.x / grid.cell_size).to_i
+    y = (inputs.mouse.point.y / grid.cell_size).to_i
+    # Bound x and y to the grid
+    x = grid.width - 1 if x > grid.width - 1
+    y = grid.height - 1 if y > grid.height - 1
+    # Return closest cell
+    [x, y]
+  end
+
+  # When the user grabs the star and puts their cursor to the far right
+  # and moves up and down, the star is supposed to move along the grid as well
+  # Finding the cell closest to the mouse in the second grid helps with this
+  def heuristic_cell_closest_to_mouse
+    # Closest cell grid to the mouse in the second
+    x = (inputs.mouse.point.x / grid.cell_size).to_i
+    y = (inputs.mouse.point.y / grid.cell_size).to_i
+    # Translate the cell to the first grid
+    x -= grid.width + 1
+    # Bound x and y to the first grid
+    x = 0 if x < 0
+    y = 0 if y < 0
+    x = grid.width - 1 if x > grid.width - 1
+    y = grid.height - 1 if y > grid.height - 1
+    # Return closest cell
+    [x, y]
+  end
+
+  def recalculate_searches
+    # Reset the searches
+    bfs.came_from    = {}
+    bfs.frontier     = []
+    bfs.path         = []
+    heuristic.came_from = {}
+    heuristic.frontier  = []
+    heuristic.path      = []
+
+    # Move the searches forward to the current step
+    state.current_step.times { move_searches_one_step_forward }
+  end
+
+  def move_searches_one_step_forward
+    bfs_one_step_forward
+    heuristic_one_step_forward
+  end
+
+  def bfs_one_step_forward
+    return if bfs.came_from.has_key?(grid.target)
+
+    # Only runs at the beginning of the search as setup.
+    if bfs.came_from.empty?
+      bfs.frontier << grid.star
+      bfs.came_from[grid.star] = nil
+    end
+
+    # A step in the search
+    unless bfs.frontier.empty?
+      # Takes the next frontier cell
+      new_frontier = bfs.frontier.shift
+      # For each of its neighbors
+      adjacent_neighbors(new_frontier).each do |neighbor|
+        # That have not been visited and are not walls
+        unless bfs.came_from.has_key?(neighbor) || grid.walls.has_key?(neighbor)
+          # Add them to the frontier and mark them as visited
+          bfs.frontier << neighbor
+          bfs.came_from[neighbor] = new_frontier
+        end
+      end
     end
 
-    outputs.labels << state.button.label
-    outputs.borders << state.button.border
+    # Sort the frontier so that cells that are in a zigzag pattern are prioritized over those in an line
+    # Comment this line and let a path generate to see the difference
+    bfs.frontier = bfs.frontier.sort_by {| cell | proximity_to_star(cell) }
+
+    # If the search found the target
+    if bfs.came_from.has_key?(grid.target)
+      # Calculate the path between the target and star
+      bfs_calc_path
+    end
+  end
+
+  # Calculates the path between the target and star for the breadth first search
+  # Only called when the breadth first search finds the target
+  def bfs_calc_path
+    # Start from the target
+    endpoint = grid.target
+    # And the cell it came from
+    next_endpoint = bfs.came_from[endpoint]
+    while endpoint and next_endpoint
+      # Draw a path between these two cells and store it
+      path = get_path_between(endpoint, next_endpoint)
+      bfs.path << path
+      # And get the next pair of cells
+      endpoint = next_endpoint
+      next_endpoint = bfs.came_from[endpoint]
+      # Continue till there are no more cells
+    end
+  end
+
+  # Moves the heuristic search forward one step
+  # Can be called from tick while the animation is playing
+  # Can also be called when recalculating the searches after the user edited the grid
+  def heuristic_one_step_forward
+    # Stop the search if the target has been found
+    return if heuristic.came_from.has_key?(grid.target)
+
+    # If the search has not begun
+    if heuristic.came_from.empty?
+      # Setup the search to begin from the star
+      heuristic.frontier << grid.star
+      heuristic.came_from[grid.star] = nil
+    end
+
+    # One step in the heuristic search
+
+    # Unless there are no more cells to explore from
+    unless heuristic.frontier.empty?
+      # Get the next cell to explore from
+      new_frontier = heuristic.frontier.shift
+      # For each of its neighbors
+      adjacent_neighbors(new_frontier).each do |neighbor|
+        # That have not been visited and are not walls
+        unless heuristic.came_from.has_key?(neighbor) || grid.walls.has_key?(neighbor)
+          # Add them to the frontier and mark them as visited
+          heuristic.frontier << neighbor
+          heuristic.came_from[neighbor] = new_frontier
+        end
+      end
+    end
 
-    if state.button.clicked_at # if button was clicked (variable has a value and is not nil)
+    # Sort the frontier so that cells that are in a zigzag pattern are prioritized over those in an line
+    heuristic.frontier = heuristic.frontier.sort_by {| cell | proximity_to_star(cell) }
+    # Sort the frontier so cells that are close to the target are then prioritized
+    heuristic.frontier = heuristic.frontier.sort_by {| cell | heuristic_heuristic(cell)  }
 
-      # The appearance of the button changes for 0.25 seconds after the time the button is clicked at.
-      # The color changes (rgb is set to 0, 180, 80) and the transparency gradually changes.
-      # Change 0.25 to 1.25 and notice that the transparency takes longer to return to normal.
-      outputs.solids << [x, y, w, h, 0, 180, 80, 255 * state.button.clicked_at.ease(0.25.seconds, :flip)]
+    # If the search found the target
+    if heuristic.came_from.has_key?(grid.target)
+      # Calculate the path between the target and star
+      heuristic_calc_path
     end
   end
 
-  # Creates a new button by declaring it as a new entity, and sets values.
-  def new_button_prefab x, y, message
-    w, h = 300, 50
-    button        = state.new_entity(:button_with_fade)
-    button.label  = [x + w.half, y + h.half + 10, message, 0, 1] # '+ 10' keeps label's text within button's borders
-    button.border = [x, y, w, h] # sets border definition
-    button
+  # Returns one-dimensional absolute distance between cell and target
+  # Returns a number to compare distances between cells and the target
+  def heuristic_heuristic(cell)
+    (grid.target.x - cell.x).abs + (grid.target.y - cell.y).abs
   end
 
-  # If the mouse has been clicked and the click's location is inside of the button's border, that means
-  # that the button has been clicked. This method returns a boolean value.
-  def button_clicked? button
-    inputs.mouse.click && inputs.mouse.click.point.inside_rect?(button.border)
+  # Calculates the path between the target and star for the heuristic search
+  # Only called when the heuristic search finds the target
+  def heuristic_calc_path
+    # Start from the target
+    endpoint = grid.target
+    # And the cell it came from
+    next_endpoint = heuristic.came_from[endpoint]
+    while endpoint and next_endpoint
+      # Draw a path between these two cells and store it
+      path = get_path_between(endpoint, next_endpoint)
+      heuristic.path << path
+      # And get the next pair of cells
+      endpoint = next_endpoint
+      next_endpoint = heuristic.came_from[endpoint]
+      # Continue till there are no more cells
+    end
   end
 
-  # Determines if button was clicked, and changes its appearance if it is clicked
-  def tick_button_prefab button
-    outputs.labels << button.label # outputs button's label and border
-    outputs.borders << button.border
+  # Returns a list of adjacent cells
+  # Used to determine what the next cells to be added to the frontier are
+  def adjacent_neighbors(cell)
+    neighbors = []
 
-    if button_clicked? button # if button is clicked
-      button.clicked_at = inputs.mouse.click.created_at # stores the time that the button was clicked
-    end
+    # Gets all the valid neighbors into the array
+    # From southern neighbor, clockwise
+    neighbors << [cell.x    , cell.y - 1] unless cell.y == 0
+    neighbors << [cell.x - 1, cell.y    ] unless cell.x == 0
+    neighbors << [cell.x    , cell.y + 1] unless cell.y == grid.height - 1
+    neighbors << [cell.x + 1, cell.y    ] unless cell.x == grid.width - 1
 
-    if button.clicked_at # if clicked_at has a frame value and is not nil
-      # button is output; color changes and transparency changes for 0.25 seconds after click occurs
-      outputs.solids << [button.border.x, button.border.y, button.border.w, button.border.h,
-                         0, 180, 80, 255 * button.clicked_at.ease(0.25.seconds, :flip)] # transparency changes for 0.25 seconds
-    end
+    neighbors
   end
 
-  # Exports the app's game state if the export button is clicked.
-  def export_game_state_demo
-    state.export_game_state_button ||= new_button_prefab(460, 100, "click to export app state")
-    tick_button_prefab(state.export_game_state_button) # calls method to output button
-    if button_clicked? state.export_game_state_button # if the export button is clicked
-      args.gtk.export! "Exported from clicking the export button in the tech demo." # the export occurs
+  # Finds the vertical and horizontal distance of a cell from the star
+  # and returns the larger value
+  # This method is used to have a zigzag pattern in the rendered path
+  # A cell that is [5, 5] from the star,
+  # is explored before over a cell that is [0, 7] away.
+  # So, if possible, the search tries to go diagonal (zigzag) first
+  def proximity_to_star(cell)
+    distance_x = (grid.star.x - cell.x).abs
+    distance_y = (grid.star.y - cell.y).abs
+
+    if distance_x > distance_y
+      return distance_x
+    else
+      return distance_y
     end
   end
 
-  # The mouse and keyboard focus are set to "yes" when the Dragonruby window is the active window.
-  def window_state_demo
-    m = $gtk.args.inputs.mouse.has_focus ? 'Y' : 'N' # ternary operator (similar to if statement)
-    k = $gtk.args.inputs.keyboard.has_focus ? 'Y' : 'N'
-    outputs.labels << [460, 20, "mouse focus: #{m}   keyboard focus: #{k}", small_font]
+  # Methods that allow code to be more concise. Subdivides args.state, which is where all variables are stored.
+  def grid
+    state.grid
   end
 
-  #Sets values for the horizontal separator (divides demo sections)
-  def horizontal_seperator y, x, x2
-    [x, y, x2, y, 150, 150, 150]
+  def buttons
+    state.buttons
   end
 
-  #Sets the values for the vertical separator (divides demo sections)
-  def vertical_seperator x, y, y2
-    [x, y, x, y2, 150, 150, 150]
+  def slider
+    state.slider
   end
 
-  # Outputs vertical and horizontal separators onto the screen to separate each demo section.
-  def render_seperators
-    outputs.lines << horizontal_seperator(505, grid.left, 445)
-    outputs.lines << horizontal_seperator(353, grid.left, 445)
-    outputs.lines << horizontal_seperator(264, grid.left, 445)
-    outputs.lines << horizontal_seperator(174, grid.left, 445)
+  def bfs
+    state.bfs
+  end
 
-    outputs.lines << vertical_seperator(445, grid.top, grid.bottom)
+  def heuristic
+    state.heuristic
+  end
 
-    outputs.lines << horizontal_seperator(690, 445, 820)
-    outputs.lines << horizontal_seperator(426, 445, 820)
+  # Descriptive aliases for colors
+  def default_color
+    [221, 212, 213] # Light Brown
+  end
 
-    outputs.lines << vertical_seperator(820, grid.top, grid.bottom)
+  def wall_color
+    [134, 134, 120] # Camo Green
   end
-end
 
-$tech_demo = TechDemo.new
+  def visited_color
+    [204, 191, 179] # Dark Brown
+  end
 
-def tick args
-  $tech_demo.inputs = args.inputs
-  $tech_demo.state = args.state
-  $tech_demo.grid = args.grid
-  $tech_demo.args = args
-  $tech_demo.outputs = args.render_target(:mini_map)
-  $tech_demo.tick
-  args.outputs.labels  << [830, 715, "Render target:", [-2, 0, 0, 0, 0, 255]]
-  args.outputs.sprites << [0, 0, 1280, 720, :mini_map]
-  args.outputs.sprites << [830, 300, 675, 379, :mini_map]
-  tick_instructions args, "Sample app shows all the rendering apis available."
+  def frontier_color
+    [103, 136, 204] # Blue
+  end
+
+  def path_color
+    [231, 230, 228] # Pastel White
+  end
+
+  def button_color
+    [190, 190, 190] # Gray
+  end
 end
+# Method that is called by DragonRuby periodically
+# Used for updating animations and calculations
+def tick args
 
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
+  # Pressing r will reset the application
+  if args.inputs.keyboard.key_down.r
+    args.gtk.reset
+    reset
+    return
   end
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+  # Every tick, new args are passed, and the Breadth First Search tick is called
+  $heuristic ||= Heuristic.new(args)
+  $heuristic.args = args
+  $heuristic.tick
 end
 
-
-Advanced Rendering - Render Primitive Hierarchies - main.rb
-# ./samples/07_advanced_rendering/04_render_primitive_hierarchies/app/main.rb
-=begin
 
- APIs listing that haven't been encountered in previous sample apps:
+def reset
+  $heuristic = nil
+end
 
- - Nested array: An array whose individual elements are also arrays; useful for
-   storing groups of similar data.  Also called multidimensional arrays.
+
+Path Finding Algorithms - A Star - main.rb
+# ./samples/13_path_finding_algorithms/08_a_star/app/main.rb
+# This program is inspired by https://www.redblobgames.com/pathfinding/a-star/introduction.html
 
-   In this sample app, we see nested arrays being used in object definitions.
-   Notice the parameters for solids, listed below. Parameters 1-3 set the
-   definition for the rect, and parameter 4 sets the definition of the color.
+# The A* Search works by incorporating both the distance from the starting point
+# and the distance from the target in its heurisitic.
 
-   Instead of having a solid definition that looks like this,
-   [X, Y, W, H, R, G, B]
-   we can separate it into two separate array definitions in one, like this
-   [[X, Y, W, H], [R, G, B]]
-   and both options work fine in defining our solid (or any object).
+# It tends to find the correct (shortest) path even when the Greedy Best-First Search does not,
+# and it explores less of the grid, and is therefore faster, than Dijkstra's Search.
 
- - Collections: Lists of data; useful for organizing large amounts of data.
-   One element of a collection could be an array (which itself contains many elements).
-   For example, a collection that stores two solid objects would look like this:
-   [
-    [100, 100, 50, 50, 0, 0, 0],
-    [100, 150, 50, 50, 255, 255, 255]
-   ]
-   If this collection was added to args.outputs.solids, two solids would be output
-   next to each other, one black and one white.
-   Nested arrays can be used in collections, as you will see in this sample app.
+class A_Star_Algorithm
+  attr_gtk
+
+  def tick
+    defaults
+    render
+    input
+
+    if dijkstra.came_from.empty?
+      calc_searches
+    end
+  end
+
+  def defaults
+    # Variables to edit the size and appearance of the grid
+    # Freely customizable to user's liking
+    grid.width     ||= 15
+    grid.height    ||= 15
+    grid.cell_size ||= 27
+    grid.rect      ||= [0, 0, grid.width, grid.height]
+
+    grid.star      ||= [0, 2]
+    grid.target    ||= [11, 13]
+    grid.walls     ||= {
+      [2, 2] => true,
+      [3, 2] => true,
+      [4, 2] => true,
+      [5, 2] => true,
+      [6, 2] => true,
+      [7, 2] => true,
+      [8, 2] => true,
+      [9, 2] => true,
+      [10, 2] => true,
+      [11, 2] => true,
+      [12, 2] => true,
+      [12, 3] => true,
+      [12, 4] => true,
+      [12, 5] => true,
+      [12, 6] => true,
+      [12, 7] => true,
+      [12, 8] => true,
+      [12, 9] => true,
+      [12, 10] => true,
+      [12, 11] => true,
+      [12, 12] => true,
+      [5, 12] => true,
+      [6, 12] => true,
+      [7, 12] => true,
+      [8, 12] => true,
+      [9, 12] => true,
+      [10, 12] => true,
+      [11, 12] => true,
+      [12, 12] => true
+    }
+
+    # What the user is currently editing on the grid
+    # We store this value, because we want to remember the value even when
+    # the user's cursor is no longer over what they're interacting with, but
+    # they are still clicking down on the mouse.
+    state.user_input ||= :none
+
+    # These variables allow the breadth first search to take place
+    # Came_from is a hash with a key of a cell and a value of the cell that was expanded from to find the key.
+    # Used to prevent searching cells that have already been found
+    # and to trace a path from the target back to the starting point.
+    # Frontier is an array of cells to expand the search from.
+    # The search is over when there are no more cells to search from.
+    # Path stores the path from the target to the star, once the target has been found
+    # It prevents calculating the path every tick.
+    dijkstra.came_from   ||= {}
+    dijkstra.cost_so_far ||= {}
+    dijkstra.frontier    ||= []
+    dijkstra.path        ||= []
+
+    greedy.came_from ||= {}
+    greedy.frontier  ||= []
+    greedy.path      ||= []
+
+    a_star.frontier  ||= []
+    a_star.came_from ||= {}
+    a_star.path      ||= []
+  end
+
+  # All methods with render draw stuff on the screen
+  # UI has buttons, the slider, and labels
+  # The search specific rendering occurs in the respective methods
+  def render
+    render_labels
+    render_dijkstra
+    render_greedy
+    render_a_star
+  end
+
+  def render_labels
+    outputs.labels << [150, 450, "Dijkstra's"]
+    outputs.labels << [550, 450, "Greedy Best-First"]
+    outputs.labels << [1025, 450, "A* Search"]
+  end
+
+  def render_dijkstra
+    render_dijkstra_grid
+    render_dijkstra_star
+    render_dijkstra_target
+    render_dijkstra_visited
+    render_dijkstra_walls
+    render_dijkstra_path
+  end
 
- Reminders:
+  def render_greedy
+    render_greedy_grid
+    render_greedy_star
+    render_greedy_target
+    render_greedy_visited
+    render_greedy_walls
+    render_greedy_path
+  end
 
- - args.outputs.solids: An array. The values generate a solid.
-   The parameters for a solid are
-   1. The position on the screen (x, y)
-   2. The width (w)
-   3. The height (h)
-   4. The color (r, g, b) (if a color is not assigned, the object's default color will be black)
-   NOTE: THE PARAMETERS ARE THE SAME FOR BORDERS!
+  def render_a_star
+    render_a_star_grid
+    render_a_star_star
+    render_a_star_target
+    render_a_star_visited
+    render_a_star_walls
+    render_a_star_path
+  end
 
-   Here is an example of a (red) border or solid definition:
-   [100, 100, 400, 500, 255, 0, 0]
-   It will be a solid or border depending on if it is added to args.outputs.solids or args.outputs.borders.
-   For more information about solids and borders, go to mygame/documentation/03-solids-and-borders.md.
+  # This method handles user input every tick
+  def input
+    # If the mouse was lifted this tick
+    if inputs.mouse.up
+      # Set current input to none
+      state.user_input = :none
+    end
 
- - args.outputs.sprites: An array. The values generate a sprite.
-   The parameters for sprites are
-   1. The position on the screen (x, y)
-   2. The width (w)
-   3. The height (h)
-   4. The image path (p)
+    # If the mouse was clicked this tick
+    if inputs.mouse.down
+      # Determine what the user is editing and appropriately edit the state.user_input variable
+      determine_input
+    end
 
-   Here is an example of a sprite definition:
-   [100, 100, 400, 500, 'sprites/dragonruby.png']
-   For more information about sprites, go to mygame/documentation/05-sprites.md.
+    # Process user input based on user_input variable and current mouse position
+    process_input
+  end
 
-=end
+  # Determines what the user is editing
+  # This method is called when the mouse is clicked down
+  def determine_input
+    # If the mouse is over the star in the first grid
+    if dijkstra_mouse_over_star?
+      # The user is editing the star from the first grid
+      state.user_input = :dijkstra_star
+    # If the mouse is over the star in the second grid
+    elsif greedy_mouse_over_star?
+      # The user is editing the star from the second grid
+      state.user_input = :greedy_star
+    # If the mouse is over the star in the third grid
+    elsif a_star_mouse_over_star?
+      # The user is editing the star from the third grid
+      state.user_input = :a_star_star
+    # If the mouse is over the target in the first grid
+    elsif dijkstra_mouse_over_target?
+      # The user is editing the target from the first grid
+      state.user_input = :dijkstra_target
+    # If the mouse is over the target in the second grid
+    elsif greedy_mouse_over_target?
+      # The user is editing the target from the second grid
+      state.user_input = :greedy_target
+    # If the mouse is over the target in the third grid
+    elsif a_star_mouse_over_target?
+      # The user is editing the target from the third grid
+      state.user_input = :a_star_target
+    # If the mouse is over a wall in the first grid
+    elsif dijkstra_mouse_over_wall?
+      # The user is removing a wall from the first grid
+      state.user_input = :dijkstra_remove_wall
+    # If the mouse is over a wall in the second grid
+    elsif greedy_mouse_over_wall?
+      # The user is removing a wall from the second grid
+      state.user_input = :greedy_remove_wall
+    # If the mouse is over a wall in the third grid
+    elsif a_star_mouse_over_wall?
+      # The user is removing a wall from the third grid
+      state.user_input = :a_star_remove_wall
+    # If the mouse is over the first grid
+    elsif dijkstra_mouse_over_grid?
+      # The user is adding a wall from the first grid
+      state.user_input = :dijkstra_add_wall
+    # If the mouse is over the second grid
+    elsif greedy_mouse_over_grid?
+      # The user is adding a wall from the second grid
+      state.user_input = :greedy_add_wall
+    # If the mouse is over the third grid
+    elsif a_star_mouse_over_grid?
+      # The user is adding a wall from the third grid
+      state.user_input = :a_star_add_wall
+    end
+  end
+
+  # Processes click and drag based on what the user is currently dragging
+  def process_input
+    if state.user_input == :dijkstra_star
+      process_input_dijkstra_star
+    elsif state.user_input == :greedy_star
+      process_input_greedy_star
+    elsif state.user_input == :a_star_star
+      process_input_a_star_star
+    elsif state.user_input == :dijkstra_target
+      process_input_dijkstra_target
+    elsif state.user_input == :greedy_target
+      process_input_greedy_target
+    elsif state.user_input == :a_star_target
+      process_input_a_star_target
+    elsif state.user_input == :dijkstra_remove_wall
+      process_input_dijkstra_remove_wall
+    elsif state.user_input == :greedy_remove_wall
+      process_input_greedy_remove_wall
+    elsif state.user_input == :a_star_remove_wall
+      process_input_a_star_remove_wall
+    elsif state.user_input == :dijkstra_add_wall
+      process_input_dijkstra_add_wall
+    elsif state.user_input == :greedy_add_wall
+      process_input_greedy_add_wall
+    elsif state.user_input == :a_star_add_wall
+      process_input_a_star_add_wall
+    end
+  end
 
-# This code demonstrates the creation and output of objects like sprites, borders, and solids
-# If filled in, they are solids
-# If hollow, they are borders
-# If images, they are sprites
+  def render_dijkstra_grid
+    # A large rect the size of the grid
+    outputs.solids << [dijkstra_scale_up(grid.rect), default_color]
 
-# Solids are added to args.outputs.solids
-# Borders are added to args.outputs.borders
-# Sprites are added to args.outputs.sprites
+    # The vertical grid lines
+    for x in 0..grid.width
+      outputs.lines << dijkstra_vertical_line(x)
+    end
 
-# The tick method runs 60 frames every second.
-# Your game is going to happen under this one function.
-def tick args
-  border_as_solid_and_solid_as_border args
-  sprite_as_border_or_solids args
-  collection_of_borders_and_solids args
-  collection_of_sprites args
-end
+    # The horizontal grid lines
+    for y in 0..grid.height
+      outputs.lines << dijkstra_horizontal_line(y)
+    end
+  end
 
-# Shows a border being output onto the screen as a border and a solid
-# Also shows how colors can be set
-def border_as_solid_and_solid_as_border args
-  border = [0, 0, 50, 50]
-  args.outputs.borders << border
-  args.outputs.solids  << border
+  def render_greedy_grid
+    # A large rect the size of the grid
+    outputs.solids << [greedy_scale_up(grid.rect), default_color]
 
-  # Red, green, blue saturations (last three parameters) can be any number between 0 and 255
-  border_with_color = [0, 100, 50, 50, 255, 0, 0]
-  args.outputs.borders << border_with_color
-  args.outputs.solids  << border_with_color
+    # The vertical grid lines
+    for x in 0..grid.width
+      outputs.lines << greedy_vertical_line(x)
+    end
 
-  border_with_nested_color = [0, 200, 50, 50, [0, 255, 0]] # nested color
-  args.outputs.borders << border_with_nested_color
-  args.outputs.solids  << border_with_nested_color
+    # The horizontal grid lines
+    for y in 0..grid.height
+      outputs.lines << greedy_horizontal_line(y)
+    end
+  end
 
-  border_with_nested_rect = [[0, 300, 50, 50], 0, 0, 255] # nested rect
-  args.outputs.borders << border_with_nested_rect
-  args.outputs.solids  << border_with_nested_rect
+  def render_a_star_grid
+    # A large rect the size of the grid
+    outputs.solids << [a_star_scale_up(grid.rect), default_color]
 
-  border_with_nested_color_and_rect = [[0, 400, 50, 50], [255, 0, 255]] # nested rect and color
-  args.outputs.borders << border_with_nested_color_and_rect
-  args.outputs.solids  << border_with_nested_color_and_rect
-end
+    # The vertical grid lines
+    for x in 0..grid.width
+      outputs.lines << a_star_vertical_line(x)
+    end
 
-# Shows a sprite output onto the screen as a sprite, border, and solid
-# Demonstrates that all three outputs appear differently on screen
-def sprite_as_border_or_solids args
-  sprite = [100, 0, 50, 50, 'sprites/ship.png']
-  args.outputs.sprites << sprite
+    # The horizontal grid lines
+    for y in 0..grid.height
+      outputs.lines << a_star_horizontal_line(y)
+    end
+  end
 
-  # Sprite_as_border variable has same parameters (excluding position) as above object,
-  # but will appear differently on screen because it is added to args.outputs.borders
-  sprite_as_border = [100, 100, 50, 50, 'sprites/ship.png']
-  args.outputs.borders << sprite_as_border
+  # Returns a vertical line for a column of the first grid
+  def dijkstra_vertical_line column
+    dijkstra_scale_up([column, 0, column, grid.height])
+  end
 
-  # Sprite_as_solid variable has same parameters (excluding position) as above object,
-  # but will appear differently on screen because it is added to args.outputs.solids
-  sprite_as_solid = [100, 200, 50, 50, 'sprites/ship.png']
-  args.outputs.solids << sprite_as_solid
-end
+  # Returns a horizontal line for a column of the first grid
+  def dijkstra_horizontal_line row
+    dijkstra_scale_up([0, row, grid.width, row])
+  end
 
-# Holds and outputs a collection of borders and a collection of solids
-# Collections are created by using arrays to hold parameters of each individual object
-def collection_of_borders_and_solids args
-  collection_borders = [
-    [
-      [200,  0, 50, 50],                    # black border
-      [200,  100, 50, 50, 255, 0, 0],       # red border
-      [200,  200, 50, 50, [0, 255, 0]],     # nested color
-    ],
-    [[200, 300, 50, 50], 0, 0, 255],        # nested rect
-    [[200, 400, 50, 50], [255, 0, 255]]     # nested rect and nested color
-  ]
+  # Returns a vertical line for a column of the second grid
+  def greedy_vertical_line column
+    dijkstra_scale_up([column + grid.width + 1, 0, column + grid.width + 1, grid.height])
+  end
 
-  args.outputs.borders << collection_borders
+  # Returns a horizontal line for a column of the second grid
+  def greedy_horizontal_line row
+    dijkstra_scale_up([grid.width + 1, row, grid.width + grid.width + 1, row])
+  end
 
-  collection_solids = [
-    [
-      [[300, 300, 50, 50], 0, 0, 255],      # nested rect
-      [[300, 400, 50, 50], [255, 0, 255]]   # nested rect and nested color
-    ],
-    [300,  0, 50, 50],
-    [300,  100, 50, 50, 255, 0, 0],
-    [300,  200, 50, 50, [0, 255, 0]],       # nested color
-  ]
+  # Returns a vertical line for a column of the third grid
+  def a_star_vertical_line column
+    dijkstra_scale_up([column + (grid.width * 2) + 2, 0, column + (grid.width * 2) + 2, grid.height])
+  end
 
-  args.outputs.solids << collection_solids
-end
+  # Returns a horizontal line for a column of the third grid
+  def a_star_horizontal_line row
+    dijkstra_scale_up([(grid.width * 2) + 2, row, (grid.width * 2) + grid.width + 2, row])
+  end
 
-# Holds and outputs a collection of sprites by adding it to args.outputs.sprites
-# Also outputs a collection with same parameters (excluding position) by adding
-# it to args.outputs.solids and another to args.outputs.borders
-def collection_of_sprites args
-  sprites_collection = [
-    [
-      [400, 0, 50, 50, 'sprites/ship.png'],
-      [400, 100, 50, 50, 'sprites/ship.png'],
-    ],
-    [400, 200, 50, 50, 'sprites/ship.png']
-  ]
+  # Renders the star on the first grid
+  def render_dijkstra_star
+    outputs.sprites << [dijkstra_scale_up(grid.star), 'star.png']
+  end
 
-  args.outputs.sprites << sprites_collection
+  # Renders the star on the second grid
+  def render_greedy_star
+    outputs.sprites << [greedy_scale_up(grid.star), 'star.png']
+  end
 
-  args.outputs.solids << [
-    [500, 0, 50, 50, 'sprites/ship.png'],
-    [500, 100, 50, 50, 'sprites/ship.png'],
-    [[[500, 200, 50, 50, 'sprites/ship.png']]]
-  ]
+  # Renders the star on the third grid
+  def render_a_star_star
+    outputs.sprites << [a_star_scale_up(grid.star), 'star.png']
+  end
 
-  args.outputs.borders << [
-    [
-      [600, 0, 50, 50, 'sprites/ship.png'],
-      [600, 100, 50, 50, 'sprites/ship.png'],
-    ],
-    [600, 200, 50, 50, 'sprites/ship.png']
-  ]
-end
+  # Renders the target on the first grid
+  def render_dijkstra_target
+    outputs.sprites << [dijkstra_scale_up(grid.target), 'target.png']
+  end
 
-

-Advanced Rendering - Render Primitives As Hash - main.rb
-# ./samples/07_advanced_rendering/05_render_primitives_as_hash/app/main.rb
-=begin
+  # Renders the target on the second grid
+  def render_greedy_target
+    outputs.sprites << [greedy_scale_up(grid.target), 'target.png']
+  end
 
- Reminders:
+  # Renders the target on the third grid
+  def render_a_star_target
+    outputs.sprites << [a_star_scale_up(grid.target), 'target.png']
+  end
 
- - Hashes: Collection of unique keys and their corresponding values. The value can be found
-   using their keys.
+  # Renders the walls on the first grid
+  def render_dijkstra_walls
+    grid.walls.each_key do | wall |
+      outputs.solids << [dijkstra_scale_up(wall), wall_color]
+    end
+  end
 
-   For example, if we have a "numbers" hash that stores numbers in English as the
-   key and numbers in Spanish as the value, we'd have a hash that looks like this...
-   numbers = { "one" => "uno", "two" => "dos", "three" => "tres" }
-   and on it goes.
+  # Renders the walls on the second grid
+  def render_greedy_walls
+    grid.walls.each_key do | wall |
+      outputs.solids << [greedy_scale_up(wall), wall_color]
+    end
+  end
 
-   Now if we wanted to find the corresponding value of the "one" key, we could say
-   puts numbers["one"]
-   which would print "uno" to the console.
+  # Renders the walls on the third grid
+  def render_a_star_walls
+    grid.walls.each_key do | wall |
+      outputs.solids << [a_star_scale_up(wall), wall_color]
+    end
+  end
 
- - args.outputs.sprites: An array. The values generate a sprite.
-   The parameters are [X, Y, WIDTH, HEIGHT, PATH, ANGLE, ALPHA, RED, GREEN, BLUE]
-   For more information about sprites, go to mygame/documentation/05-sprites.md.
+  # Renders the visited cells on the first grid
+  def render_dijkstra_visited
+    dijkstra.came_from.each_key do | visited_cell |
+      outputs.solids << [dijkstra_scale_up(visited_cell), visited_color]
+    end
+  end
 
- - args.outputs.labels: An array. The values generate a label.
-   The parameters are [X, Y, TEXT, SIZE, ALIGNMENT, RED, GREEN, BLUE, ALPHA, FONT STYLE]
-   For more information about labels, go to mygame/documentation/02-labels.md.
+  # Renders the visited cells on the second grid
+  def render_greedy_visited
+    greedy.came_from.each_key do | visited_cell |
+      outputs.solids << [greedy_scale_up(visited_cell), visited_color]
+    end
+  end
 
- - args.outputs.solids: An array. The values generate a solid.
-   The parameters are [X, Y, WIDTH, HEIGHT, RED, GREEN, BLUE, ALPHA]
-   For more information about solids, go to mygame/documentation/03-solids-and-borders.md.
+  # Renders the visited cells on the third grid
+  def render_a_star_visited
+    a_star.came_from.each_key do | visited_cell |
+      outputs.solids << [a_star_scale_up(visited_cell), visited_color]
+    end
+  end
 
- - args.outputs.borders: An array. The values generate a border.
-   The parameters are the same as a solid.
-   For more information about borders, go to mygame/documentation/03-solids-and-borders.md.
+  # Renders the path found by the breadth first search on the first grid
+  def render_dijkstra_path
+    dijkstra.path.each do | path |
+      outputs.solids << [dijkstra_scale_up(path), path_color]
+    end
+  end
 
- - args.outputs.lines: An array. The values generate a line.
-   The parameters are [X1, Y1, X2, Y2, RED, GREEN, BLUE]
-   For more information about labels, go to mygame/documentation/02-labels.md.
+  # Renders the path found by the greedy search on the second grid
+  def render_greedy_path
+    greedy.path.each do | path |
+      outputs.solids << [greedy_scale_up(path), path_color]
+    end
+  end
 
-=end
+  # Renders the path found by the a_star search on the third grid
+  def render_a_star_path
+    a_star.path.each do | path |
+      outputs.solids << [a_star_scale_up(path), path_color]
+    end
+  end
 
-# This sample app demonstrates how hashes can be used to output different kinds of objects.
+  # Returns the rect for the path between two cells based on their relative positions
+  def get_path_between(cell_one, cell_two)
+    path = []
 
-def tick args
-  args.state.angle ||= 0 # initializes angle to 0
-  args.state.angle  += 1 # increments angle by 1 every frame (60 times a second)
+    # If cell one is above cell two
+    if cell_one.x == cell_two.x and cell_one.y > cell_two.y
+      # Path starts from the center of cell two and moves upward to the center of cell one
+      path = [cell_two.x + 0.3, cell_two.y + 0.3, 0.4, 1.4]
+    # If cell one is below cell two
+    elsif cell_one.x == cell_two.x and cell_one.y < cell_two.y
+      # Path starts from the center of cell one and moves upward to the center of cell two
+      path = [cell_one.x + 0.3, cell_one.y + 0.3, 0.4, 1.4]
+    # If cell one is to the left of cell two
+    elsif cell_one.x > cell_two.x and cell_one.y == cell_two.y
+      # Path starts from the center of cell two and moves rightward to the center of cell one
+      path = [cell_two.x + 0.3, cell_two.y + 0.3, 1.4, 0.4]
+    # If cell one is to the right of cell two
+    elsif cell_one.x < cell_two.x and cell_one.y == cell_two.y
+      # Path starts from the center of cell one and moves rightward to the center of cell two
+      path = [cell_one.x + 0.3, cell_one.y + 0.3, 1.4, 0.4]
+    end
 
-  # Outputs sprite using a hash
-  args.outputs.sprites << {
-    x: 30,                          # sprite position
-    y: 550,
-    w: 128,                         # sprite size
-    h: 101,
-    path: "dragonruby.png",         # image path
-    angle: args.state.angle,        # angle
-    a: 255,                         # alpha (transparency)
-    r: 255,                         # color saturation
-    g: 255,
-    b: 255,
-    tile_x:  0,                     # sprite sub division/tile
-    tile_y:  0,
-    tile_w: -1,
-    tile_h: -1,
-    flip_vertically: false,         # don't flip sprite
-    flip_horizontally: false,
-    angle_anchor_x: 0.5,            # rotation center set to middle
-    angle_anchor_y: 0.5
-  }
+    path
+  end
 
-  # Outputs label using a hash
-  args.outputs.labels << {
-    x:              200,                 # label position
-    y:              550,
-    text:           "dragonruby",        # label text
-    size_enum:      2,
-    alignment_enum: 1,
-    r:              155,                 # color saturation
-    g:              50,
-    b:              50,
-    a:              255,                 # transparency
-    font:           "fonts/manaspc.ttf"  # font style; without mentioned file, label won't output correctly
-  }
+  # In code, the cells are represented as 1x1 rectangles
+  # When drawn, the cells are larger than 1x1 rectangles
+  # This method is used to scale up cells, and lines
+  # Objects are scaled up according to the grid.cell_size variable
+  # This allows for easy customization of the visual scale of the grid
+  # This method scales up cells for the first grid
+  def dijkstra_scale_up(cell)
+    # Prevents the original value of cell from being edited
+    cell = cell.clone
 
-  # Outputs solid using a hash
-  # [X, Y, WIDTH, HEIGHT, RED, GREEN, BLUE, ALPHA]
-  args.outputs.solids << {
-    x: 400,                         # position
-    y: 550,
-    w: 160,                         # size
-    h:  90,
-    r: 120,                         # color saturation
-    g:  50,
-    b:  50,
-    a: 255                          # transparency
-  }
+    # If cell is just an x and y coordinate
+    if cell.size == 2
+      # Add a width and height of 1
+      cell << 1
+      cell << 1
+    end
+
+    # Scale all the values up
+    cell.map! { |value| value * grid.cell_size }
+
+    # Returns the scaled up cell
+    cell
+  end
+
+  # Translates the given cell grid.width + 1 to the right and then scales up
+  # Used to draw cells for the second grid
+  # This method does not work for lines,
+  # so separate methods exist for the grid lines
+  def greedy_scale_up(cell)
+    # Prevents the original value of cell from being edited
+    cell = cell.clone
+    # Translates the cell to the second grid equivalent
+    cell.x += grid.width + 1
+    # Proceeds as if scaling up for the first grid
+    dijkstra_scale_up(cell)
+  end
 
-  # Outputs border using a hash
-  # Same parameters as a solid
-  args.outputs.borders << {
-    x: 600,
-    y: 550,
-    w: 160,
-    h:  90,
-    r: 120,
-    g:  50,
-    b:  50,
-    a: 255
-  }
+  # Translates the given cell (grid.width + 1) * 2 to the right and then scales up
+  # Used to draw cells for the third grid
+  # This method does not work for lines,
+  # so separate methods exist for the grid lines
+  def a_star_scale_up(cell)
+    # Prevents the original value of cell from being edited
+    cell = cell.clone
+    # Translates the cell to the second grid equivalent
+    cell.x += grid.width + 1
+    # Translates the cell to the third grid equivalent
+    cell.x += grid.width + 1
+    # Proceeds as if scaling up for the first grid
+    dijkstra_scale_up(cell)
+  end
 
-  # Outputs line using a hash
-  args.outputs.lines << {
-    x:  900,                        # starting position
-    y:  550,
-    x2: 1200,                       # ending position
-    y2: 550,
-    r:  120,                        # color saturation
-    g:   50,
-    b:   50,
-    a:  255                         # transparency
-  }
+  # Signal that the user is going to be moving the star from the first grid
+  def dijkstra_mouse_over_star?
+    inputs.mouse.point.inside_rect?(dijkstra_scale_up(grid.star))
+  end
 
-  # Outputs sprite as a primitive using a hash
-  args.outputs.primitives << {
-    x: 30,                          # position
-    y: 200,
-    w: 128,                         # size
-    h: 101,
-    path: "dragonruby.png",         # image path
-    angle: args.state.angle,        # angle
-    a: 255,                         # transparency
-    r: 255,                         # color saturation
-    g: 255,
-    b: 255,
-    tile_x:  0,                     # sprite sub division/tile
-    tile_y:  0,
-    tile_w: -1,
-    tile_h: -1,
-    flip_vertically: false,         # don't flip
-    flip_horizontally: false,
-    angle_anchor_x: 0.5,            # rotation center set to middle
-    angle_anchor_y: 0.5
-  }.sprite
+  # Signal that the user is going to be moving the star from the second grid
+  def greedy_mouse_over_star?
+    inputs.mouse.point.inside_rect?(greedy_scale_up(grid.star))
+  end
 
-  # Outputs label as primitive using a hash
-  args.outputs.primitives << {
-    x:         200,                 # position
-    y:         200,
-    text:      "dragonruby",        # text
-    size:      2,
-    alignment: 1,
-    r:         155,                 # color saturation
-    g:         50,
-    b:         50,
-    a:         255,                 # transparency
-    font:      "fonts/manaspc.ttf"  # font style
-  }.label
+  # Signal that the user is going to be moving the star from the third grid
+  def a_star_mouse_over_star?
+    inputs.mouse.point.inside_rect?(a_star_scale_up(grid.star))
+  end
 
-  # Outputs solid as primitive using a hash
-  args.outputs.primitives << {
-    x: 400,                         # position
-    y: 200,
-    w: 160,                         # size
-    h:  90,
-    r: 120,                         # color saturation
-    g:  50,
-    b:  50,
-    a: 255                          # transparency
-  }.solid
+  # Signal that the user is going to be moving the target from the first grid
+  def dijkstra_mouse_over_target?
+    inputs.mouse.point.inside_rect?(dijkstra_scale_up(grid.target))
+  end
 
-  # Outputs border as primitive using a hash
-  # Same parameters as solid
-  args.outputs.primitives << {
-    x: 600,                         # position
-    y: 200,
-    w: 160,                         # size
-    h:  90,
-    r: 120,                         # color saturation
-    g:  50,
-    b:  50,
-    a: 255                          # transparency
-  }.border
+  # Signal that the user is going to be moving the target from the second grid
+  def greedy_mouse_over_target?
+    inputs.mouse.point.inside_rect?(greedy_scale_up(grid.target))
+  end
 
-  # Outputs line as primitive using a hash
-  args.outputs.primitives << {
-    x:  900,                        # starting position
-    y:  200,
-    x2: 1200,                       # ending position
-    y2: 200,
-    r:  120,                        # color saturation
-    g:   50,
-    b:   50,
-    a:  255                         # transparency
-  }.line
-end
+  # Signal that the user is going to be moving the target from the third grid
+  def a_star_mouse_over_target?
+    inputs.mouse.point.inside_rect?(a_star_scale_up(grid.target))
+  end
 
-
-Advanced Rendering - Pixel Arrays - main.rb
-# ./samples/07_advanced_rendering/06_pixel_arrays/app/main.rb
-$gtk.reset
+  # Signal that the user is going to be removing walls from the first grid
+  def dijkstra_mouse_over_wall?
+    grid.walls.each_key do | wall |
+      return true if inputs.mouse.point.inside_rect?(dijkstra_scale_up(wall))
+    end
 
-def tick args
-  args.state.posinc ||= 1
-  args.state.pos ||= 0
-  args.state.rotation ||= 0
+    false
+  end
 
-  dimension = 10  # keep it small and let the GPU scale it when rendering the sprite.
+  # Signal that the user is going to be removing walls from the second grid
+  def greedy_mouse_over_wall?
+    grid.walls.each_key do | wall |
+      return true if inputs.mouse.point.inside_rect?(greedy_scale_up(wall))
+    end
 
-  # Set up our "scanner" pixel array and fill it with black pixels.
-  args.pixel_array(:scanner).width = dimension
-  args.pixel_array(:scanner).height = dimension
-  args.pixel_array(:scanner).pixels.fill(0xFF000000, 0, dimension * dimension)  # black, full alpha
+    false
+  end
 
-  # Draw a green line that bounces up and down the sprite.
-  args.pixel_array(:scanner).pixels.fill(0xFF00FF00, dimension * args.state.pos, dimension)  # green, full alpha
+  # Signal that the user is going to be removing walls from the third grid
+  def a_star_mouse_over_wall?
+    grid.walls.each_key do | wall |
+      return true if inputs.mouse.point.inside_rect?(a_star_scale_up(wall))
+    end
 
-  # Adjust position for next frame.
-  args.state.pos += args.state.posinc
-  if args.state.posinc > 0 && args.state.pos >= dimension
-    args.state.posinc = -1
-    args.state.pos = dimension - 1
-  elsif args.state.posinc < 0 && args.state.pos < 0
-    args.state.posinc = 1
-    args.state.pos = 1
+    false
   end
 
-  # New/changed pixel arrays get uploaded to the GPU before we render
-  #  anything. At that point, they can be scaled, rotated, and otherwise
-  #  used like any other sprite.
-  w = 100
-  h = 100
-  x = (1280 - w) / 2
-  y = (720 - h) / 2
-  args.outputs.background_color = [64, 0, 128]
-  args.outputs.primitives << [x, y, w, h, :scanner, args.state.rotation].sprite
-  args.state.rotation += 1
+  # Signal that the user is going to be adding walls from the first grid
+  def dijkstra_mouse_over_grid?
+    inputs.mouse.point.inside_rect?(dijkstra_scale_up(grid.rect))
+  end
 
-  args.outputs.primitives << args.gtk.current_framerate_primitives
-end
+  # Signal that the user is going to be adding walls from the second grid
+  def greedy_mouse_over_grid?
+    inputs.mouse.point.inside_rect?(greedy_scale_up(grid.rect))
+  end
 
+  # Signal that the user is going to be adding walls from the third grid
+  def a_star_mouse_over_grid?
+    inputs.mouse.point.inside_rect?(a_star_scale_up(grid.rect))
+  end
 
-
-Tweening Lerping Easing Functions - Easing Functions - main.rb
-# ./samples/08_tweening_lerping_easing_functions/01_easing_functions/app/main.rb
-def tick args
-  # STOP! Watch the following presentation first!!!!
-  # Math for Game Programmers: Fast and Funky 1D Nonlinear Transformations
-  # https://www.youtube.com/watch?v=mr5xkf6zSzk
+  # Moves the star to the cell closest to the mouse in the first grid
+  # Only resets the search if the star changes position
+  # Called whenever the user is editing the star (puts mouse down on star)
+  def process_input_dijkstra_star
+    old_star = grid.star.clone
+    unless dijkstra_cell_closest_to_mouse == grid.target
+      grid.star = dijkstra_cell_closest_to_mouse
+    end
+    unless old_star == grid.star
+      reset_searches
+    end
+  end
 
-  # You've watched the talk, yes? YES???
+  # Moves the star to the cell closest to the mouse in the second grid
+  # Only resets the search if the star changes position
+  # Called whenever the user is editing the star (puts mouse down on star)
+  def process_input_greedy_star
+    old_star = grid.star.clone
+    unless greedy_cell_closest_to_mouse == grid.target
+      grid.star = greedy_cell_closest_to_mouse
+    end
+    unless old_star == grid.star
+      reset_searches
+    end
+  end
 
-  # define starting and ending points of properties to animate
-  args.state.target_x = 1180
-  args.state.target_y = 620
-  args.state.target_w = 100
-  args.state.target_h = 100
-  args.state.starting_x = 0
-  args.state.starting_y = 0
-  args.state.starting_w = 300
-  args.state.starting_h = 300
+  # Moves the star to the cell closest to the mouse in the third grid
+  # Only resets the search if the star changes position
+  # Called whenever the user is editing the star (puts mouse down on star)
+  def process_input_a_star_star
+    old_star = grid.star.clone
+    unless a_star_cell_closest_to_mouse == grid.target
+      grid.star = a_star_cell_closest_to_mouse
+    end
+    unless old_star == grid.star
+      reset_searches
+    end
+  end
 
-  # define start time and duration of animation
-  args.state.start_animate_at = 3.seconds # this is the same as writing 60 * 5 (or 300)
-  args.state.duration = 2.seconds # this is the same as writing 60 * 2 (or 120)
+  # Moves the target to the grid closest to the mouse in the first grid
+  # Only reset_searchess the search if the target changes position
+  # Called whenever the user is editing the target (puts mouse down on target)
+  def process_input_dijkstra_target
+    old_target = grid.target.clone
+    unless dijkstra_cell_closest_to_mouse == grid.star
+      grid.target = dijkstra_cell_closest_to_mouse
+    end
+    unless old_target == grid.target
+      reset_searches
+    end
+  end
 
-  # define type of animations
-  # Here are all the options you have for values you can put in the array:
-  # :identity, :quad, :cube, :quart, :quint, :flip
+  # Moves the target to the cell closest to the mouse in the second grid
+  # Only reset_searchess the search if the target changes position
+  # Called whenever the user is editing the target (puts mouse down on target)
+  def process_input_greedy_target
+    old_target = grid.target.clone
+    unless greedy_cell_closest_to_mouse == grid.star
+      grid.target = greedy_cell_closest_to_mouse
+    end
+    unless old_target == grid.target
+      reset_searches
+    end
+  end
 
-  # Linear is defined as:
-  # [:identity]
-  #
-  # Smooth start variations are:
-  # [:quad]
-  # [:cube]
-  # [:quart]
-  # [:quint]
+  # Moves the target to the cell closest to the mouse in the third grid
+  # Only reset_searchess the search if the target changes position
+  # Called whenever the user is editing the target (puts mouse down on target)
+  def process_input_a_star_target
+    old_target = grid.target.clone
+    unless a_star_cell_closest_to_mouse == grid.star
+      grid.target = a_star_cell_closest_to_mouse
+    end
+    unless old_target == grid.target
+      reset_searches
+    end
+  end
 
-  # Linear reversed, and smooth stop are the same as the animations defined above, but reversed:
-  # [:flip, :identity]
-  # [:flip, :quad, :flip]
-  # [:flip, :cube, :flip]
-  # [:flip, :quart, :flip]
-  # [:flip, :quint, :flip]
+  # Removes walls in the first grid that are under the cursor
+  def process_input_dijkstra_remove_wall
+    # The mouse needs to be inside the grid, because we only want to remove walls
+    # the cursor is directly over
+    # Recalculations should only occur when a wall is actually deleted
+    if dijkstra_mouse_over_grid?
+      if grid.walls.has_key?(dijkstra_cell_closest_to_mouse)
+        grid.walls.delete(dijkstra_cell_closest_to_mouse)
+        reset_searches
+      end
+    end
+  end
 
-  # You can also do custom definitions. See the bottom of the file details
-  # on how to do that. I've defined a couple for you:
-  # [:smoothest_start]
-  # [:smoothest_stop]
+  # Removes walls in the second grid that are under the cursor
+  def process_input_greedy_remove_wall
+    # The mouse needs to be inside the grid, because we only want to remove walls
+    # the cursor is directly over
+    # Recalculations should only occur when a wall is actually deleted
+    if greedy_mouse_over_grid?
+      if grid.walls.has_key?(greedy_cell_closest_to_mouse)
+        grid.walls.delete(greedy_cell_closest_to_mouse)
+        reset_searches
+      end
+    end
+  end
 
-  # CHANGE THIS LINE TO ONE OF THE LINES ABOVE TO SEE VARIATIONS
-  args.state.animation_type = [:identity]
-  # args.state.animation_type = [:quad]
-  # args.state.animation_type = [:cube]
-  # args.state.animation_type = [:quart]
-  # args.state.animation_type = [:quint]
-  # args.state.animation_type = [:flip, :identity]
-  # args.state.animation_type = [:flip, :quad, :flip]
-  # args.state.animation_type = [:flip, :cube, :flip]
-  # args.state.animation_type = [:flip, :quart, :flip]
-  # args.state.animation_type = [:flip, :quint, :flip]
-  # args.state.animation_type = [:smoothest_start]
-  # args.state.animation_type = [:smoothest_stop]
+  # Removes walls in the third grid that are under the cursor
+  def process_input_a_star_remove_wall
+    # The mouse needs to be inside the grid, because we only want to remove walls
+    # the cursor is directly over
+    # Recalculations should only occur when a wall is actually deleted
+    if a_star_mouse_over_grid?
+      if grid.walls.has_key?(a_star_cell_closest_to_mouse)
+        grid.walls.delete(a_star_cell_closest_to_mouse)
+        reset_searches
+      end
+    end
+  end
 
-  # THIS IS WHERE THE MAGIC HAPPENS!
-  # Numeric#ease
-  progress = args.state.start_animate_at.ease(args.state.duration, args.state.animation_type)
+  # Adds a wall in the first grid in the cell the mouse is over
+  def process_input_dijkstra_add_wall
+    if dijkstra_mouse_over_grid?
+      unless grid.walls.has_key?(dijkstra_cell_closest_to_mouse)
+        grid.walls[dijkstra_cell_closest_to_mouse] = true
+        reset_searches
+      end
+    end
+  end
 
-  # Numeric#ease needs to called:
-  # 1. On the number that represents the point in time you want to start, and takes two parameters:
-  #   a. The first parameter is how long the animation should take.
-  #   b. The second parameter represents the functions that need to be called.
-  #
-  # For example, if I wanted an animate to start 3 seconds in, and last for 10 seconds,
-  # and I want to animation to start fast and end slow, I would do:
-  # (60 * 3).ease(60 * 10, :flip, :quint, :flip)
+  # Adds a wall in the second grid in the cell the mouse is over
+  def process_input_greedy_add_wall
+    if greedy_mouse_over_grid?
+      unless grid.walls.has_key?(greedy_cell_closest_to_mouse)
+        grid.walls[greedy_cell_closest_to_mouse] = true
+        reset_searches
+      end
+    end
+  end
 
-  #        initial value           delta to the final value
-  calc_x = args.state.starting_x + (args.state.target_x - args.state.starting_x) * progress
-  calc_y = args.state.starting_y + (args.state.target_y - args.state.starting_y) * progress
-  calc_w = args.state.starting_w + (args.state.target_w - args.state.starting_w) * progress
-  calc_h = args.state.starting_h + (args.state.target_h - args.state.starting_h) * progress
+  # Adds a wall in the third grid in the cell the mouse is over
+  def process_input_a_star_add_wall
+    if a_star_mouse_over_grid?
+      unless grid.walls.has_key?(a_star_cell_closest_to_mouse)
+        grid.walls[a_star_cell_closest_to_mouse] = true
+        reset_searches
+      end
+    end
+  end
+
+  # When the user grabs the star and puts their cursor to the far right
+  # and moves up and down, the star is supposed to move along the grid as well
+  # Finding the cell closest to the mouse helps with this
+  def dijkstra_cell_closest_to_mouse
+    # Closest cell to the mouse in the first grid
+    x = (inputs.mouse.point.x / grid.cell_size).to_i
+    y = (inputs.mouse.point.y / grid.cell_size).to_i
+    # Bound x and y to the grid
+    x = grid.width - 1 if x > grid.width - 1
+    y = grid.height - 1 if y > grid.height - 1
+    # Return closest cell
+    [x, y]
+  end
+
+  # When the user grabs the star and puts their cursor to the far right
+  # and moves up and down, the star is supposed to move along the grid as well
+  # Finding the cell closest to the mouse in the second grid helps with this
+  def greedy_cell_closest_to_mouse
+    # Closest cell grid to the mouse in the second
+    x = (inputs.mouse.point.x / grid.cell_size).to_i
+    y = (inputs.mouse.point.y / grid.cell_size).to_i
+    # Translate the cell to the first grid
+    x -= grid.width + 1
+    # Bound x and y to the first grid
+    x = 0 if x < 0
+    y = 0 if y < 0
+    x = grid.width - 1 if x > grid.width - 1
+    y = grid.height - 1 if y > grid.height - 1
+    # Return closest cell
+    [x, y]
+  end
+
+  # When the user grabs the star and puts their cursor to the far right
+  # and moves up and down, the star is supposed to move along the grid as well
+  # Finding the cell closest to the mouse in the third grid helps with this
+  def a_star_cell_closest_to_mouse
+    # Closest cell grid to the mouse in the second
+    x = (inputs.mouse.point.x / grid.cell_size).to_i
+    y = (inputs.mouse.point.y / grid.cell_size).to_i
+    # Translate the cell to the first grid
+    x -= (grid.width + 1) * 2
+    # Bound x and y to the first grid
+    x = 0 if x < 0
+    y = 0 if y < 0
+    x = grid.width - 1 if x > grid.width - 1
+    y = grid.height - 1 if y > grid.height - 1
+    # Return closest cell
+    [x, y]
+  end
+
+  def reset_searches
+    # Reset the searches
+    dijkstra.came_from      = {}
+    dijkstra.cost_so_far    = {}
+    dijkstra.frontier       = []
+    dijkstra.path           = []
+
+    greedy.came_from = {}
+    greedy.frontier  = []
+    greedy.path      = []
+    a_star.came_from = {}
+    a_star.frontier  = []
+    a_star.path      = []
+  end
+
+  def calc_searches
+    calc_dijkstra
+    calc_greedy
+    calc_a_star
+    # Move the searches forward to the current step
+    # state.current_step.times { move_searches_one_step_forward }
+  end
+
+  def calc_dijkstra
+    # Sets up the search to begin from the star
+    dijkstra.frontier << grid.star
+    dijkstra.came_from[grid.star] = nil
+    dijkstra.cost_so_far[grid.star] = 0
+
+    # Until the target is found or there are no more cells to explore from
+    until dijkstra.came_from.has_key?(grid.target) or dijkstra.frontier.empty?
+      # Take the next frontier cell. The first element is the cell, the second is the priority.
+      new_frontier = dijkstra.frontier.shift#[0]
+      # For each of its neighbors
+      adjacent_neighbors(new_frontier).each do | neighbor |
+        # That have not been visited and are not walls
+        unless dijkstra.came_from.has_key?(neighbor) or grid.walls.has_key?(neighbor)
+          # Add them to the frontier and mark them as visited
+          dijkstra.frontier << neighbor
+          dijkstra.came_from[neighbor] = new_frontier
+          dijkstra.cost_so_far[neighbor] = dijkstra.cost_so_far[new_frontier] + 1
+        end
+      end
+
+      # Sort the frontier so that cells that are in a zigzag pattern are prioritized over those in an line
+      # Comment this line and let a path generate to see the difference
+      dijkstra.frontier = dijkstra.frontier.sort_by {| cell | proximity_to_star(cell) }
+      dijkstra.frontier = dijkstra.frontier.sort_by {| cell | dijkstra.cost_so_far[cell] }
+    end
+
+
+    # If the search found the target
+    if dijkstra.came_from.has_key?(grid.target)
+      # Calculate the path between the target and star
+      dijkstra_calc_path
+    end
+  end
+
+  def calc_greedy
+    # Sets up the search to begin from the star
+    greedy.frontier << grid.star
+    greedy.came_from[grid.star] = nil
+
+    # Until the target is found or there are no more cells to explore from
+    until greedy.came_from.has_key?(grid.target) or greedy.frontier.empty?
+      # Take the next frontier cell
+      new_frontier = greedy.frontier.shift
+      # For each of its neighbors
+      adjacent_neighbors(new_frontier).each do | neighbor |
+        # That have not been visited and are not walls
+        unless greedy.came_from.has_key?(neighbor) or grid.walls.has_key?(neighbor)
+          # Add them to the frontier and mark them as visited
+          greedy.frontier << neighbor
+          greedy.came_from[neighbor] = new_frontier
+        end
+      end
+      # Sort the frontier so that cells that are in a zigzag pattern are prioritized over those in an line
+      # Comment this line and let a path generate to see the difference
+      greedy.frontier = greedy.frontier.sort_by {| cell | proximity_to_star(cell) }
+      # Sort the frontier so cells that are close to the target are then prioritized
+      greedy.frontier = greedy.frontier.sort_by {| cell | greedy_heuristic(cell)  }
+    end
 
-  args.outputs.solids << [calc_x, calc_y, calc_w, calc_h, 0, 0, 0]
 
-  # count down
-  count_down = args.state.start_animate_at - args.state.tick_count
-  if count_down > 0
-    args.outputs.labels << [640, 375, "Running: #{args.state.animation_type} in...", 3, 1]
-    args.outputs.labels << [640, 345, "%.2f" % count_down.fdiv(60), 3, 1]
-  elsif progress >= 1
-    args.outputs.labels << [640, 360, "Click screen to reset.", 3, 1]
-    if args.inputs.click
-      $gtk.reset
+    # If the search found the target
+    if greedy.came_from.has_key?(grid.target)
+      # Calculate the path between the target and star
+      greedy_calc_path
     end
   end
-end
 
-# $gtk.reset
+  def calc_a_star
+    # Setup the search to start from the star
+    a_star.came_from[grid.star] = nil
+    a_star.cost_so_far[grid.star] = 0
+    a_star.frontier << grid.star
 
-# you can make own variations of animations using this
-module Easing
-  # you have access to all the built in functions: identity, flip, quad, cube, quart, quint
-  def self.smoothest_start x
-    quad(quint(x))
-  end
+    # Until there are no more cells to explore from or the search has found the target
+    until a_star.frontier.empty? or a_star.came_from.has_key?(grid.target)
+      # Get the next cell to expand from
+      current_frontier = a_star.frontier.shift
 
-  def self.smoothest_stop x
-    flip(quad(quint(flip(x))))
-  end
+      # For each of that cells neighbors
+      adjacent_neighbors(current_frontier).each do | neighbor |
+        # That have not been visited and are not walls
+        unless a_star.came_from.has_key?(neighbor) or grid.walls.has_key?(neighbor)
+          # Add them to the frontier and mark them as visited
+          a_star.frontier << neighbor
+          a_star.came_from[neighbor] = current_frontier
+          a_star.cost_so_far[neighbor] = a_star.cost_so_far[current_frontier] + 1
+        end
+      end
 
-  # this is the source for the existing easing functions
-  def self.identity x
-    x
+      # Sort the frontier so that cells that are in a zigzag pattern are prioritized over those in an line
+      # Comment this line and let a path generate to see the difference
+      a_star.frontier = a_star.frontier.sort_by {| cell | proximity_to_star(cell) }
+      a_star.frontier = a_star.frontier.sort_by {| cell | a_star.cost_so_far[cell] + greedy_heuristic(cell) }
+    end
+
+    # If the search found the target
+    if a_star.came_from.has_key?(grid.target)
+      # Calculate the path between the target and star
+      a_star_calc_path
+    end
+  end
+
+  # Calculates the path between the target and star for the breadth first search
+  # Only called when the breadth first search finds the target
+  def dijkstra_calc_path
+    # Start from the target
+    endpoint = grid.target
+    # And the cell it came from
+    next_endpoint = dijkstra.came_from[endpoint]
+    while endpoint and next_endpoint
+      # Draw a path between these two cells and store it
+      path = get_path_between(endpoint, next_endpoint)
+      dijkstra.path << path
+      # And get the next pair of cells
+      endpoint = next_endpoint
+      next_endpoint = dijkstra.came_from[endpoint]
+      # Continue till there are no more cells
+    end
+  end
+
+  # Returns one-dimensional absolute distance between cell and target
+  # Returns a number to compare distances between cells and the target
+  def greedy_heuristic(cell)
+    (grid.target.x - cell.x).abs + (grid.target.y - cell.y).abs
+  end
+
+  # Calculates the path between the target and star for the greedy search
+  # Only called when the greedy search finds the target
+  def greedy_calc_path
+    # Start from the target
+    endpoint = grid.target
+    # And the cell it came from
+    next_endpoint = greedy.came_from[endpoint]
+    while endpoint and next_endpoint
+      # Draw a path between these two cells and store it
+      path = get_path_between(endpoint, next_endpoint)
+      greedy.path << path
+      # And get the next pair of cells
+      endpoint = next_endpoint
+      next_endpoint = greedy.came_from[endpoint]
+      # Continue till there are no more cells
+    end
+  end
+
+  # Calculates the path between the target and star for the a_star search
+  # Only called when the a_star search finds the target
+  def a_star_calc_path
+    # Start from the target
+    endpoint = grid.target
+    # And the cell it came from
+    next_endpoint = a_star.came_from[endpoint]
+
+    while endpoint and next_endpoint
+      # Draw a path between these two cells and store it
+      path = get_path_between(endpoint, next_endpoint)
+      a_star.path << path
+      # And get the next pair of cells
+      endpoint = next_endpoint
+      next_endpoint = a_star.came_from[endpoint]
+      # Continue till there are no more cells
+    end
+  end
+
+  # Returns a list of adjacent cells
+  # Used to determine what the next cells to be added to the frontier are
+  def adjacent_neighbors(cell)
+    neighbors = []
+
+    # Gets all the valid neighbors into the array
+    # From southern neighbor, clockwise
+    neighbors << [cell.x    , cell.y - 1] unless cell.y == 0
+    neighbors << [cell.x - 1, cell.y    ] unless cell.x == 0
+    neighbors << [cell.x    , cell.y + 1] unless cell.y == grid.height - 1
+    neighbors << [cell.x + 1, cell.y    ] unless cell.x == grid.width - 1
+
+    neighbors
+  end
+
+  # Finds the vertical and horizontal distance of a cell from the star
+  # and returns the larger value
+  # This method is used to have a zigzag pattern in the rendered path
+  # A cell that is [5, 5] from the star,
+  # is explored before over a cell that is [0, 7] away.
+  # So, if possible, the search tries to go diagonal (zigzag) first
+  def proximity_to_star(cell)
+    distance_x = (grid.star.x - cell.x).abs
+    distance_y = (grid.star.y - cell.y).abs
+
+    if distance_x > distance_y
+      return distance_x
+    else
+      return distance_y
+    end
   end
 
-  def self.flip x
-    1 - x
+  # Methods that allow code to be more concise. Subdivides args.state, which is where all variables are stored.
+  def grid
+    state.grid
   end
 
-  def self.quad x
-    x * x
+  def dijkstra
+    state.dijkstra
   end
 
-  def self.cube x
-    x * x * x
+  def greedy
+    state.greedy
   end
 
-  def self.quart x
-    x * x * x * x * x
+  def a_star
+    state.a_star
   end
 
-  def self.quint x
-    x * x * x * x * x * x
+  # Descriptive aliases for colors
+  def default_color
+    [221, 212, 213] # Light Brown
   end
-end
-
-
-Tweening Lerping Easing Functions - Cubic Bezier - main.rb
-# ./samples/08_tweening_lerping_easing_functions/02_cubic_bezier/app/main.rb
-def tick args
-  args.outputs.background_color = [33, 33, 33]
-  args.outputs.lines << bezier(100, 100,
-                               100, 620,
-                               1180, 620,
-                               1180, 100,
-                               0)
 
-  args.outputs.lines << bezier(100, 100,
-                               100, 620,
-                               1180, 620,
-                               1180, 100,
-                               20)
-end
-
-
-def bezier x1, y1, x2, y2, x3, y3, x4, y4, step
-  step ||= 0
-  color = [200, 200, 200]
-  points = points_for_bezier [x1, y1], [x2, y2], [x3, y3], [x4, y4], step
-
-  points.each_cons(2).map do |p1, p2|
-    [p1, p2, color]
+  def wall_color
+    [134, 134, 120] # Camo Green
   end
-end
 
-def points_for_bezier p1, p2, p3, p4, step
-  points = []
-  if step == 0
-    [p1, p2, p3, p4]
-  else
-    t_step = 1.fdiv(step + 1)
-    t = 0
-    t += t_step
-    points = []
-    while t < 1
-      points << [
-        b_for_t(p1.x, p2.x, p3.x, p4.x, t),
-        b_for_t(p1.y, p2.y, p3.y, p4.y, t),
-      ]
-      t += t_step
-    end
+  def visited_color
+    [204, 191, 179] # Dark Brown
+  end
 
-    [
-      p1,
-      *points,
-      p4
-    ]
+  def path_color
+    [231, 230, 228] # Pastel White
   end
-end
 
-def b_for_t v0, v1, v2, v3, t
-  pow(1 - t, 3) * v0 +
-  3 * pow(1 - t, 2) * t * v1 +
-  3 * (1 - t) * pow(t, 2) * v2 +
-  pow(t, 3) * v3
+  def button_color
+    [190, 190, 190] # Gray
+  end
 end
 
-def pow n, to
-  n ** to
-end
 
-
-Tweening Lerping Easing Functions - Easing Using Spline - main.rb
-# ./samples/08_tweening_lerping_easing_functions/03_easing_using_spline/app/main.rb
+# Method that is called by DragonRuby periodically
+# Used for updating animations and calculations
 def tick args
-  args.state.duration = 10.seconds
-  args.state.spline = [
-    [0.0, 0.33, 0.66, 1.0],
-    [1.0, 1.0,  1.0,  1.0],
-    [1.0, 0.66, 0.33, 0.0],
-  ]
 
-  args.state.simulation_tick = args.state.tick_count % args.state.duration
-  progress = 0.ease_spline_extended args.state.simulation_tick, args.state.duration, args.state.spline
-  args.outputs.borders << args.grid.rect
-  args.outputs.solids << [20 + 1240 * progress,
-                          20 +  680 * progress,
-                          20, 20].anchor_rect(0.5, 0.5)
-  args.outputs.labels << [10,
-                          710,
-                          "perc: #{"%.2f" % (args.state.simulation_tick / args.state.duration)} t: #{args.state.simulation_tick}"]
-end
+  # Pressing r will reset the application
+  if args.inputs.keyboard.key_down.r
+    args.gtk.reset
+    reset
+    return
+  end
 
-
-Tweening Lerping Easing Functions - Parametric Enemy Movement - main.rb
-# ./samples/08_tweening_lerping_easing_functions/04_parametric_enemy_movement/app/main.rb
-def new_star args
-  { x: 1280.randomize(:ratio),
-    starting_y: 800,
-    distance_to_travel: 900 + 100.randomize(:ratio),
-    duration: 100.randomize(:ratio) + 60,
-    created_at: args.state.tick_count,
-    max_alpha: 128.randomize(:ratio) + 128,
-    b: 255.randomize(:ratio),
-    g: 200.randomize(:ratio),
-    w: 1.randomize(:ratio) + 1,
-    h: 1.randomize(:ratio) + 1 }
+  # Every tick, new args are passed, and the Breadth First Search tick is called
+  $a_star_algorithm ||= A_Star_Algorithm.new(args)
+  $a_star_algorithm.args = args
+  $a_star_algorithm.tick
 end
 
-def new_enemy args
-  { x: 1280.randomize(:ratio),
-    starting_y: 800,
-    distance_to_travel: -900,
-    duration: 60.randomize(:ratio) + 180,
-    created_at: args.state.tick_count,
-    w: 32,
-    h: 32,
-    fire_rate: (30.randomize(:ratio) + (60 - args.state.score)).to_i }
-end
 
-def new_bullet args, starting_x, starting_y, enemy_speed
-  { x: starting_x,
-    starting_y: starting_y,
-    distance_to_travel: -900,
-    created_at: args.state.tick_count,
-    duration: 900 / (enemy_speed.abs + 2.0 + (5.0 * args.state.score.fdiv(100))).abs,
-    w: 5,
-    h: 5 }
+def reset
+  $a_star_algorithm = nil
 end
 
-def new_player_bullet args, starting_x, starting_y, player_speed
-  { x: starting_x,
-    starting_y: starting_y,
-    distance_to_travel: 900,
-    created_at: args.state.tick_count,
-    duration: 900 / (player_speed + 2.0),
-    w: 5,
-    h: 5 }
+
+Path Finding Algorithms - Tower Defense - main.rb
+# ./samples/13_path_finding_algorithms/09_tower_defense/app/main.rb
+# An example of some major components in a tower defence game
+# The pathing of the tanks is determined by A* algorithm -- try editing the walls
+
+# The turrets shoot bullets at the closest tank. The bullets are heat-seeking
+
+def tick args
+  $gtk.reset if args.inputs.keyboard.key_down.r
+  defaults args
+  render args
+  calc args
 end
 
 def defaults args
-  args.outputs.background_color  = [0, 0, 0]
-  args.state.score             ||= 0
-  args.state.stars             ||= []
-  args.state.enemies           ||= []
-  args.state.bullets           ||= []
-  args.state.player_bullets    ||= []
-  args.state.max_stars           = 50
-  args.state.max_enemies         = 10
-  args.state.player.x          ||= 640
-  args.state.player.y          ||= 100
-  args.state.player.w          ||= 32
-  args.state.player.h          ||= 32
+  args.outputs.background_color = wall_color
+  args.state.grid_size = 5
+  args.state.tile_size = 50
+  args.state.grid_start ||= [0, 0]
+  args.state.grid_goal  ||= [4, 4]
+
+  # Try editing these walls to see the path change!
+  args.state.walls ||= {
+    [0, 4] => true,
+    [1, 3] => true,
+    [3, 1] => true,
+    # [4, 0] => true,
+  }
 
-  if args.state.tick_count == 0
-    args.state.stars.clear
-    args.state.max_stars.times do
-      s = new_star args
-      s[:created_at] += s[:duration].randomize(:ratio)
-      args.state.stars << s
-    end
+  args.state.a_star.frontier ||= []
+  args.state.a_star.came_from ||= {}
+  args.state.a_star.path ||= []
+
+  args.state.tanks ||= []
+  args.state.tank_spawn_period ||= 60
+  args.state.tank_sprite_path ||= 'sprites/circle/white.png'
+  args.state.tank_speed ||= 1
+
+  args.state.turret_shoot_period = 10
+  # Turrets can be entered as [x, y] but are immediately mapped to hashes
+  # Walls are also added where the turrets are to prevent tanks from pathing over them
+  args.state.turrets ||= [
+    [2, 2]
+  ].each { |turret| args.state.walls[turret] = true}.map do |x, y|
+    {
+      x: x * args.state.tile_size,
+      y: y * args.state.tile_size,
+      w: args.state.tile_size,
+      h: args.state.tile_size,
+      path: 'sprites/circle/gray.png',
+      range: 100
+    }
   end
 
-  if args.state.tick_count == 0
-    args.state.enemies.clear
-    args.state.max_enemies.times do
-      s = new_enemy args
-      s[:created_at] += s[:duration].randomize(:ratio)
-      args.state.enemies << s
-    end
-  end
+  args.state.bullet_size ||= 25
+  args.state.bullets ||= []
+  args.state.bullet_path ||= 'sprites/circle/orange.png'
+  #
 end
 
-def input args
-  if args.inputs.keyboard.left
-    args.state.player.x -= 5
-  elsif args.inputs.keyboard.right
-    args.state.player.x += 5
-  end
+def render args
+  render_grid args
+  render_a_star args
+  args.outputs.sprites << args.state.tanks
+  args.outputs.sprites << args.state.turrets
+  args.outputs.sprites << args.state.bullets
+end
 
-  if args.inputs.keyboard.up
-    args.state.player.y += 5
-  elsif args.inputs.keyboard.down
-    args.state.player.y -= 5
-  end
+def render_grid args
+  # Draw a square the size and color of the grid
+  args.outputs.solids << [
+    0,
+    0,
+    args.state.grid_size * args.state.tile_size,
+    args.state.grid_size * args.state.tile_size,
+    grid_color
+  ]
 
-  if args.inputs.keyboard.key_down.space
-    args.state.player_bullets << new_player_bullet(args,
-                                                   args.state.player.x + args.state.player.w.half,
-                                                   args.state.player.y + args.state.player.h, 5)
+  # Draw lines across the grid to show tiles
+  (args.state.grid_size + 1).times do | value |
+    render_horizontal_line(args, value)
+    render_vertical_line(args, value)
   end
 
-  args.state.player.y = args.state.player.y.greater(0).lesser(720 - args.state.player.w)
-  args.state.player.x = args.state.player.x.greater(0).lesser(1280 - args.state.player.h)
+  # Render special tiles
+  render_tile(args, args.state.grid_start, start_color)
+  render_tile(args, args.state.grid_goal, goal_color)
+  args.state.walls.keys.each { |wall| render_tile(args, wall, wall_color) }
 end
 
-def completed? entity
-  (entity[:created_at] + entity[:duration]).elapsed_time > 0
+def render_vertical_line args, x
+  args.outputs.lines << [
+    x * args.state.tile_size,
+    0,
+    x * args.state.tile_size,
+    args.state.tile_size * args.state.grid_size,
+  ]
 end
 
-def calc_stars args
-  if (stars_to_add = args.state.max_stars - args.state.stars.length) > 0
-    stars_to_add.times { args.state.stars << new_star(args) }
-  end
-  args.state.stars = args.state.stars.reject { |s| completed? s }
+def render_horizontal_line args, y
+  args.outputs.lines << [
+    0,
+    y * args.state.tile_size,
+    args.state.tile_size * args.state.grid_size,
+    y * args.state.tile_size,
+  ]
 end
 
-def move_enemies args
-  if (enemies_to_add = args.state.max_enemies - args.state.enemies.length) > 0
-    enemies_to_add.times { args.state.enemies << new_enemy(args) }
-  end
-
-  args.state.enemies = args.state.enemies.reject { |s| completed? s }
+def render_tile args, tile, color
+  args.outputs.solids << [
+    tile.x * args.state.tile_size,
+    tile.y * args.state.tile_size,
+    args.state.tile_size,
+    args.state.tile_size,
+    color
+  ]
 end
 
-def move_bullets args
-  args.state.enemies.each do |e|
-    if args.state.tick_count.mod_zero?(e[:fire_rate])
-      args.state.bullets << new_bullet(args, e[:x] + e[:w].half, current_y(e), e[:distance_to_travel] / e[:duration])
-    end
-  end
-
-  args.state.bullets = args.state.bullets.reject { |s| completed? s }
-  args.state.player_bullets = args.state.player_bullets.reject { |s| completed? s }
+def calc args
+  calc_a_star args
+  calc_tanks args
+  calc_turrets args
+  calc_bullets args
 end
 
-def intersect? entity_one, entity_two
-  entity_one.merge(y: current_y(entity_one))
-            .intersect_rect? entity_two.merge(y: current_y(entity_two))
-end
+def calc_a_star args
+  # Only does this one time
+  return unless args.state.a_star.path.empty?
 
-def kill args
-  bullets_hitting_enemies = []
-  dead_bullets = []
-  dead_enemies = []
+  # Start the search from the grid start
+  args.state.a_star.frontier << args.state.grid_start
+  args.state.a_star.came_from[args.state.grid_start] = nil
 
-  args.state.player_bullets.each do |b|
-    args.state.enemies.each do |e|
-      if intersect? b, e
-        dead_bullets << b
-        dead_enemies << e
-      end
+  # Until a path to the goal has been found or there are no more tiles to explore
+  until (args.state.a_star.came_from.has_key?(args.state.grid_goal)|| args.state.a_star.frontier.empty?)
+    # For the first tile in the frontier
+    tile_to_expand_from = args.state.a_star.frontier.shift
+    # Add each of its neighbors to the frontier
+    neighbors(args, tile_to_expand_from).each do | tile |
+      args.state.a_star.frontier << tile
+      args.state.a_star.came_from[tile] = tile_to_expand_from
     end
   end
 
-  args.state.score += dead_enemies.length
-
-  args.state.player_bullets.reject! { |b| dead_bullets.include? b }
-  args.state.enemies.reject! { |e| dead_enemies.include? e }
+  # Stop calculating a path if the goal was never reached
+  return unless args.state.a_star.came_from.has_key? args.state.grid_goal
 
-  dead = args.state.bullets.any? do |b|
-    [args.state.player.x,
-     args.state.player.y,
-     args.state.player.w,
-     args.state.player.h].intersect_rect? b.merge(y: current_y(b))
+  # Fill path by tracing back from the goal
+  current_cell = args.state.grid_goal
+  while current_cell
+    args.state.a_star.path.unshift current_cell
+    current_cell = args.state.a_star.came_from[current_cell]
   end
-  return unless dead
-  args.gtk.reset
-  defaults args
-end
 
-def calc args
-  calc_stars args
-  move_enemies args
-  move_bullets args
-  kill args
+  puts "The path has been calculated"
+  puts args.state.a_star.path
 end
 
-def current_y entity
-  entity[:starting_y] + (entity[:distance_to_travel] * entity[:created_at].ease(entity[:duration], :identity))
+def calc_tanks args
+  spawn_tank args
+  move_tanks args
 end
 
-def render args
-  args.outputs.solids << args.state.stars.map do |s|
-    [s[:x],
-     current_y(s),
-     s[:w], s[:h], 0, s[:g], s[:b], s[:max_alpha] * s[:created_at].ease(20, :identity)]
+def move_tanks args
+  # Remove tanks that have reached the end of their path
+  args.state.tanks.reject! { |tank| tank[:a_star].empty? }
+
+  # Tanks have an array that has each tile it has to go to in order from a* path
+  args.state.tanks.each do | tank |
+    destination = tank[:a_star][0]
+    # Move the tank towards the destination
+    tank[:x] += copy_sign(args.state.tank_speed, ((destination.x * args.state.tile_size) - tank[:x]))
+    tank[:y] += copy_sign(args.state.tank_speed, ((destination.y * args.state.tile_size) - tank[:y]))
+    # If the tank has reached its destination
+    if (destination.x * args.state.tile_size) == tank[:x] and
+        (destination.y * args.state.tile_size) == tank[:y]
+      # Set the destination to the next point in the path
+      tank[:a_star].shift
+    end
   end
+end
 
-  args.outputs.borders << args.state.enemies.map do |s|
-    [s[:x],
-     current_y(s),
-     s[:w], s[:h], 255, 0, 0]
+def calc_turrets args
+  return unless args.state.tick_count.mod_zero? args.state.turret_shoot_period
+  args.state.turrets.each do | turret |
+    # Finds the closest tank
+    target = nil
+    shortest_distance = turret[:range] + 1
+    args.state.tanks.each do | tank |
+      distance = distance_between(turret[:x], turret[:y], tank[:x], tank[:y])
+      if distance < shortest_distance
+        target = tank
+        shortest_distance = distance
+      end
+    end
+    # If there is a tank in range, fires a bullet
+    if target
+      args.state.bullets << {
+        x: turret[:x],
+        y: turret[:y],
+        w: args.state.bullet_size,
+        h: args.state.bullet_size,
+        path: args.state.bullet_path,
+        # Note that this makes it heat-seeking, because target is passed by reference
+        # Could do target.clone to make the bullet go to where the tank initially was
+        target: target
+      }
+    end
   end
+end
 
-  args.outputs.borders << args.state.bullets.map do |b|
-    [b[:x],
-     current_y(b),
-     b[:w], b[:h], 255, 0, 0]
+def calc_bullets args
+  # Bullets aim for the center of their targets
+  args.state.bullets.each { |bullet| move bullet, center_of(bullet[:target])}
+  args.state.bullets.reject! { |b| b.intersect_rect? b[:target] }
+end
+
+def center_of object
+  object = object.clone
+  object[:x] += 0.5
+  object[:y] += 0.5
+  object
+end
+
+def render_a_star args
+  args.state.a_star.path.map do |tile|
+    # Map each x, y coordinate to the center of the tile and scale up
+    [(tile.x + 0.5) * args.state.tile_size, (tile.y + 0.5) * args.state.tile_size]
+  end.inject do | point_a,  point_b |
+    # Render the line between each point
+    args.outputs.lines << [point_a.x, point_a.y, point_b.x, point_b.y, a_star_color]
+    point_b
   end
+end
 
-  args.outputs.borders << args.state.player_bullets.map do |b|
-    [b[:x],
-     current_y(b),
-     b[:w], b[:h], 255, 255, 255]
+# Moves object to target at speed
+def move object, target, speed = 1
+  if target.is_a? Hash
+    object[:x] += copy_sign(speed, target[:x] - object[:x])
+    object[:y] += copy_sign(speed, target[:y] - object[:y])
+  else
+    object[:x] += copy_sign(speed, target.x - object[:x])
+    object[:y] += copy_sign(speed, target.y - object[:y])
   end
+end
+#
+#
+def distance_between a_x, a_y, b_x, b_y
+  (((b_x - a_x) ** 2) + ((b_y - a_y) ** 2)) ** 0.5
+end
 
-  args.borders << [args.state.player.x,
-                   args.state.player.y,
-                   args.state.player.w,
-                   args.state.player.h, 255, 255, 255]
+def copy_sign value, sign
+  return 0 if sign == 0
+  return value if sign > 0
+  -value
+end
+#
+def spawn_tank args
+  return unless args.state.tick_count.mod_zero? args.state.tank_spawn_period
+  args.state.tanks << {
+    x: args.state.grid_start.x,
+    y: args.state.grid_start.y,
+    w: args.state.tile_size,
+    h: args.state.tile_size,
+    path: args.state.tank_sprite_path,
+    a_star: args.state.a_star.path.clone
+  }
 end
 
-def tick args
-  defaults args
-  input args
-  calc args
-  render args
+def neighbors args, tile
+  [[tile.x, tile.y - 1],
+   [tile.x, tile.y + 1],
+   [tile.x + 1, tile.y],
+   [tile.x - 1, tile.y]].reject do | neighbor |
+    args.state.a_star.came_from.has_key?(neighbor) or
+      tile_out_of_bounds?(args, neighbor) or
+      args.state.walls.has_key? neighbor
+  end
 end
 
-

-Performance - Sprites As Hash - main.rb
-# ./samples/09_performance/01_sprites_as_hash/app/main.rb
+def tile_out_of_bounds? args, tile
+  tile.x < 0 or tile.y < 0 or tile.x >= args.state.grid_size or tile.y >= args.state.grid_size
+end
 
-# Sprites represented as Hashes using the queue ~args.outputs.sprites~
-# code up, but are the "slowest" to render.
-# The reason for this is the access of the key in the Hash and also
-# because the data args.outputs.sprites is cleared every tick.
-def random_x args
-  (args.grid.w.randomize :ratio) * -1
+def grid_color
+  [133, 226, 144]
 end
 
-def random_y args
-  (args.grid.h.randomize :ratio) * -1
+def start_color
+  [226, 144, 133]
 end
 
-def random_speed
-  1 + (4.randomize :ratio)
+def goal_color
+  [226, 133, 144]
 end
 
-def new_star args
-  {
-    x: (random_x args),
-    y: (random_y args),
-    w: 4, h: 4, path: 'sprites/tiny-star.png',
-    s: random_speed
-  }
+def wall_color
+  [133, 144, 226]
 end
 
-def move_star args, star
-  star.x += star[:s]
-  star.y += star[:s]
-  if star.x > args.grid.w || star.y > args.grid.h
-    star.x = (random_x args)
-    star.y = (random_y args)
-    star[:s] = random_speed
-  end
+def a_star_color
+  [0, 0, 255]
 end
 
-def tick args
-  args.state.star_count ||= 0
+
+3d - 3d Cube - main.rb
+# ./samples/99_genre_3d/01_3d_cube/app/main.rb
+STARTX             = 0.0
+STARTY             = 0.0
+ENDY               = 20.0
+ENDX               = 20.0
+SPINPOINT          = 10
+SPINDURATION       = 400
+POINTSIZE          = 8
+BOXDEPTH           = 40
+YAW                = 1
+DISTANCE           = 10
 
-  # sets console command when sample app initially opens
-  if Kernel.global_tick_count == 0
-    puts "* INFO - Please specify the number of sprites to render."
-    args.gtk.console.set_command "reset_with count: 100"
-  end
+def tick args
+  args.outputs.background_color = [0, 0, 0]
+  a = Math.sin(args.state.tick_count / SPINDURATION) * Math.tan(args.state.tick_count / SPINDURATION)
+  s = Math.sin(a)
+  c = Math.cos(a)
+  x = STARTX
+  y = STARTY
+  offset_x = (1280 - (ENDX - STARTX)) / 2
+  offset_y =  (360 - (ENDY - STARTY)) / 2
 
-  # init
-  if args.state.tick_count == 0
-    args.state.stars = args.state.star_count.map { |i| new_star args }
+  srand(1)
+  while y < ENDY do
+    while x < ENDX do
+      if (y == STARTY ||
+          y == (ENDY / 0.5) * 2 ||
+          y == (ENDY / 0.5) * 2 + 0.5 ||
+          y == ENDY - 0.5 ||
+          x == STARTX ||
+          x == ENDX - 0.5)
+        z = rand(BOXDEPTH)
+        z *= Math.sin(a / 2)
+        x -= SPINPOINT
+        u = (x * c) - (z * s)
+        v = (x * s) + (z * c)
+        k = DISTANCE.fdiv(100) + (v / 500 * YAW)
+        u = u / k
+        v = y / k
+        w = POINTSIZE / 10 / k
+        args.outputs.sprites << { x: offset_x + u - w, y: offset_y + v - w, w: w, h: w, path: 'sprites/square-blue.png'}
+        x += SPINPOINT
+      end
+      x += 0.5
+    end
+    y += 0.5
+    x = STARTX
   end
+end
 
-  # update
-  args.state.stars.each { |s| move_star args, s }
+$gtk.reset
 
-  # render
-  args.outputs.sprites << args.state.stars
+
+3d - Wireframe - main.rb
+# ./samples/99_genre_3d/02_wireframe/app/main.rb
+def tick args
+  args.state.model   ||= Object3D.new('data/shuttle.off')
+  args.state.mtx     ||= rotate3D(0, 0, 0)
+  args.state.inv_mtx ||= rotate3D(0, 0, 0)
+  delta_mtx          = rotate3D(args.inputs.up_down * 0.01, input_roll(args) * 0.01, args.inputs.left_right * 0.01)
+  args.outputs.lines << args.state.model.edges
+  args.state.model.fast_3x3_transform! args.state.inv_mtx
+  args.state.inv_mtx = mtx_mul(delta_mtx.transpose, args.state.inv_mtx)
+  args.state.mtx     = mtx_mul(args.state.mtx, delta_mtx)
+  args.state.model.fast_3x3_transform! args.state.mtx
   args.outputs.background_color = [0, 0, 0]
-  args.outputs.primitives << args.gtk.current_framerate_primitives
+  args.outputs.debug << args.gtk.framerate_diagnostics_primitives
 end
 
-# resets game, and assigns star count given by user
-def reset_with count: count
-  $gtk.reset
-  $gtk.args.state.star_count = count
+def input_roll args
+  roll = 0
+  roll += 1 if args.inputs.keyboard.e
+  roll -= 1 if args.inputs.keyboard.q
+  roll
 end
 
-

-Performance - Sprites As Entities - main.rb
-# ./samples/09_performance/02_sprites_as_entities/app/main.rb
-# Sprites represented as Entities using the queue ~args.outputs.sprites~
-# yields nicer access apis over Hashes, but require a bit more code upfront.
-# The hash sample has to use star[:s] to get the speed of the star, but
-# an entity can use .s instead.
-def random_x args
-  (args.grid.w.randomize :ratio) * -1
+def rotate3D(theta_x = 0.1, theta_y = 0.1, theta_z = 0.1)
+  c_x, s_x = Math.cos(theta_x), Math.sin(theta_x)
+  c_y, s_y = Math.cos(theta_y), Math.sin(theta_y)
+  c_z, s_z = Math.cos(theta_z), Math.sin(theta_z)
+  rot_x    = [[1, 0, 0], [0, c_x, -s_x], [0, s_x, c_x]]
+  rot_y    = [[c_y, 0, s_y], [0, 1, 0], [-s_y, 0, c_y]]
+  rot_z    = [[c_z, -s_z, 0], [s_z, c_z, 0], [0, 0, 1]]
+  mtx_mul(mtx_mul(rot_x, rot_y), rot_z)
 end
 
-def random_y args
-  (args.grid.h.randomize :ratio) * -1
+def mtx_mul(a, b)
+  is = (0...a.length)
+  js = (0...b[0].length)
+  ks = (0...b.length)
+  is.map do |i|
+    js.map do |j|
+      ks.map do |k|
+        a[i][k] * b[k][j]
+      end.reduce(&:plus)
+    end
+  end
 end
 
-def random_speed
-  1 + (4.randomize :ratio)
-end
+class Object3D
+  attr_reader :vert_count, :face_count, :edge_count, :verts, :faces, :edges
 
-def new_star args
-  args.state.new_entity :star, {
-    x: (random_x args),
-    y: (random_y args),
-    w: 4, h: 4,
-    path: 'sprites/tiny-star.png',
-    s: random_speed
-  }
+  def initialize(path)
+    @vert_count = 0
+    @face_count = 0
+    @edge_count = 0
+    @verts      = []
+    @faces      = []
+    @edges      = []
+    _init_from_file path
+  end
+
+  def _init_from_file path
+    file_lines = $gtk.read_file(path).split("\n")
+                     .reject { |line| line.start_with?('#') || line.split(' ').length == 0 } # Strip out simple comments and blank lines
+                     .map { |line| line.split('#')[0] } # Strip out end of line comments
+                     .map { |line| line.split(' ') } # Tokenize by splitting on whitespace
+    raise "OFF file did not start with OFF." if file_lines.shift != ["OFF"] # OFF meshes are supposed to begin with "OFF" as the first line.
+    raise " line malformed" if file_lines[0].length != 3 # The second line needs to have 3 numbers. Raise an error if it doesn't.
+    @vert_count, @face_count, @edge_count = file_lines.shift&.map(&:to_i) # Update the counts
+    # Only the vertex and face counts need to be accurate. Raise an error if they are inaccurate.
+    raise "Incorrect number of vertices and/or faces (Parsed VFE header: #{@vert_count} #{@face_count} #{@edge_count})" if file_lines.length != @vert_count + @face_count
+    # Grab all the lines describing vertices.
+    vert_lines = file_lines[0, @vert_count]
+    # Grab all the lines describing faces.
+    face_lines = file_lines[@vert_count, @face_count]
+    # Create all the vertices
+    @verts = vert_lines.map_with_index { |line, id| Vertex.new(line, id) }
+    # Create all the faces
+    @faces = face_lines.map { |line| Face.new(line, @verts) }
+    # Create all the edges
+    @edges = @faces.flat_map(&:edges).uniq do |edge|
+      sorted = edge.sorted
+      [sorted.point_a, sorted.point_b]
+    end
+  end
+
+  def fast_3x3_transform! mtx
+    @verts.each { |vert| vert.fast_3x3_transform! mtx }
+  end
 end
 
-def move_star args, star
-  star.x += star.s
-  star.y += star.s
-  if star.x > args.grid.w || star.y > args.grid.h
-    star.x = (random_x args)
-    star.y = (random_y args)
-    star.s = random_speed
+class Face
+
+  attr_reader :verts, :edges
+
+  def initialize(data, verts)
+    vert_count = data[0].to_i
+    vert_ids   = data[1, vert_count].map(&:to_i)
+    @verts     = vert_ids.map { |i| verts[i] }
+    @edges     = []
+    (0...vert_count).each { |i| @edges[i] = Edge.new(verts[vert_ids[i - 1]], verts[vert_ids[i]]) }
+    @edges.rotate! 1
   end
 end
 
-def tick args
-  args.state.star_count ||= 0
+class Edge
+  attr_reader :point_a, :point_b
 
-  # sets console command when sample app initially opens
-  if Kernel.global_tick_count == 0
-    puts "* INFO - Please specify the number of sprites to render."
-    args.gtk.console.set_command "reset_with count: 100"
+  def initialize(point_a, point_b)
+    @point_a = point_a
+    @point_b = point_b
   end
 
-  # init
-  if args.state.tick_count == 0
-    args.state.stars = args.state.star_count.map { |i| new_star args }
+  def sorted
+    @point_a.id < @point_b.id ? self : Edge.new(@point_b, @point_a)
   end
 
-  # update
-  args.state.stars.each { |s| move_star args, s }
+  def draw_override ffi
+    ffi.draw_line(@point_a.render_x, @point_a.render_y, @point_b.render_x, @point_b.render_y, 255, 0, 0, 128)
+    ffi.draw_line(@point_a.render_x+1, @point_a.render_y, @point_b.render_x+1, @point_b.render_y, 255, 0, 0, 128)
+    ffi.draw_line(@point_a.render_x, @point_a.render_y+1, @point_b.render_x, @point_b.render_y+1, 255, 0, 0, 128)
+    ffi.draw_line(@point_a.render_x+1, @point_a.render_y+1, @point_b.render_x+1, @point_b.render_y+1, 255, 0, 0, 128)
+  end
 
-  # render
-  args.outputs.sprites << args.state.stars
-  args.outputs.background_color = [0, 0, 0]
-  args.outputs.primitives << args.gtk.current_framerate_primitives
+  def primitive_marker
+    :line
+  end
 end
 
-# resets game, and assigns star count given by user
-def reset_with count: count
-  $gtk.reset
-  $gtk.args.state.star_count = count
-end
+class Vertex
+  attr_accessor :x, :y, :z, :id
 
-
-Performance - Sprites As Strict Entities - main.rb
-# ./samples/09_performance/03_sprites_as_strict_entities/app/main.rb
-# Sprites represented as StrictEntities using the queue ~args.outputs.sprites~
-# yields apis access similar to Entities, but all properties that can be set on the
-# entity must be predefined with a default value. Strict entities do not support the
-# addition of new properties after the fact. They are more performant than OpenEntities
-# because of this constraint.
-def random_x args
-  (args.grid.w.randomize :ratio) * -1
-end
+  def initialize(data, id)
+    @x  = data[0].to_f
+    @y  = data[1].to_f
+    @z  = data[2].to_f
+    @id = id
+  end
 
-def random_y args
-  (args.grid.h.randomize :ratio) * -1
-end
+  def fast_3x3_transform! mtx
+    _x, _y, _z = @x, @y, @z
+    @x         = mtx[0][0] * _x + mtx[0][1] * _y + mtx[0][2] * _z
+    @y         = mtx[1][0] * _x + mtx[1][1] * _y + mtx[1][2] * _z
+    @z         = mtx[2][0] * _x + mtx[2][1] * _y + mtx[2][2] * _z
+  end
 
-def random_speed
-  1 + (4.randomize :ratio)
-end
+  def render_x
+    @x * (10 / (5 - @y)) * 170 + 640
+  end
 
-def new_star args
-  args.state.new_entity_strict(:star,
-                               x: (random_x args),
-                               y: (random_y args),
-                               w: 4, h: 4,
-                               path: 'sprites/tiny-star.png',
-                               s: random_speed) do |entity|
-    # invoke attr_sprite so that it responds to
-    # all properties that are required to render a sprite
-    entity.attr_sprite
+  def render_y
+    @z * (10 / (5 - @y)) * 170 + 360
   end
 end
-
-def move_star args, star
-  star.x += star.s
-  star.y += star.s
-  if star.x > args.grid.w || star.y > args.grid.h
-    star.x = (random_x args)
-    star.y = (random_y args)
-    star.s = random_speed
+
+3d - Wireframe - Data - what-is-this.txt
+# ./samples/99_genre_3d/02_wireframe/data/what-is-this.txt
+https://en.wikipedia.org/wiki/OFF_(file_format)
+
+Arcade - Bullet Hell - main.rb
+# ./samples/99_genre_arcade/bullet_hell/app/main.rb
+def tick args
+  args.state.base_columns   ||= 10.times.map { |n| 50 * n + 1280 / 2 - 5 * 50 + 5 }
+  args.state.base_rows      ||= 5.times.map { |n| 50 * n + 720 - 5 * 50 }
+  args.state.offset_columns = 10.times.map { |n| (n - 4.5) * Math.sin(Kernel.tick_count.to_radians) * 12 }
+  args.state.offset_rows    = 5.map { 0 }
+  args.state.columns        = 10.times.map { |i| args.state.base_columns[i] + args.state.offset_columns[i] }
+  args.state.rows           = 5.times.map { |i| args.state.base_rows[i] + args.state.offset_rows[i] }
+  args.state.explosions     ||= []
+  args.state.enemies        ||= []
+  args.state.score          ||= 0
+  args.state.wave           ||= 0
+  if args.state.enemies.empty?
+    args.state.wave      += 1
+    args.state.wave_root = Math.sqrt(args.state.wave)
+    args.state.enemies   = make_enemies
+  end
+  args.state.player         ||= {x: 620, y: 80, w: 40, h: 40, path: 'sprites/circle-gray.png', angle: 90, cooldown: 0, alive: true}
+  args.state.enemy_bullets  ||= []
+  args.state.player_bullets ||= []
+  args.state.lives          ||= 3
+  args.state.missed_shots   ||= 0
+  args.state.fired_shots    ||= 0
+
+  update_explosions args
+  update_enemy_positions args
+
+  if args.inputs.left && args.state.player[:x] > (300 + 5)
+    args.state.player[:x] -= 5
+  end
+  if args.inputs.right && args.state.player[:x] < (1280 - args.state.player[:w] - 300 - 5)
+    args.state.player[:x] += 5
+  end
+
+  args.state.enemy_bullets.each do |bullet|
+    bullet[:x] += bullet[:dx]
+    bullet[:y] += bullet[:dy]
+  end
+  args.state.player_bullets.each do |bullet|
+    bullet[:x] += bullet[:dx]
+    bullet[:y] += bullet[:dy]
+  end
+
+  args.state.enemy_bullets  = args.state.enemy_bullets.find_all { |bullet| bullet[:y].between?(-16, 736) }
+  args.state.player_bullets = args.state.player_bullets.find_all do |bullet|
+    if bullet[:y].between?(-16, 736)
+      true
+    else
+      args.state.missed_shots += 1
+      false
+    end
+  end
+
+  args.state.enemies = args.state.enemies.reject do |enemy|
+    if args.state.player[:alive] && 1500 > (args.state.player[:x] - enemy[:x]) ** 2 + (args.state.player[:y] - enemy[:y]) ** 2
+      args.state.explosions << {x: enemy[:x] + 4, y: enemy[:y] + 4, w: 32, h: 32, path: 'sprites/explosion-0.png', age: 0}
+      args.state.explosions << {x: args.state.player[:x] + 4, y: args.state.player[:y] + 4, w: 32, h: 32, path: 'sprites/explosion-0.png', age: 0}
+      args.state.player[:alive] = false
+      true
+    else
+      false
+    end
+  end
+  args.state.enemy_bullets.each do |bullet|
+    if args.state.player[:alive] && 400 > (args.state.player[:x] - bullet[:x] + 12) ** 2 + (args.state.player[:y] - bullet[:y] + 12) ** 2
+      args.state.explosions << {x: args.state.player[:x] + 4, y: args.state.player[:y] + 4, w: 32, h: 32, path: 'sprites/explosion-0.png', age: 0}
+      args.state.player[:alive] = false
+      bullet[:despawn]          = true
+    end
+  end
+  args.state.enemies = args.state.enemies.reject do |enemy|
+    args.state.player_bullets.any? do |bullet|
+      if 400 > (enemy[:x] - bullet[:x] + 12) ** 2 + (enemy[:y] - bullet[:y] + 12) ** 2
+        args.state.explosions << {x: enemy[:x] + 4, y: enemy[:y] + 4, w: 32, h: 32, path: 'sprites/explosion-0.png', age: 0}
+        bullet[:despawn] = true
+        args.state.score += 1000 * args.state.wave
+        true
+      else
+        false
+      end
+    end
   end
-end
 
-def tick args
-  args.state.star_count ||= 0
+  args.state.player_bullets = args.state.player_bullets.reject { |bullet| bullet[:despawn] }
+  args.state.enemy_bullets  = args.state.enemy_bullets.reject { |bullet| bullet[:despawn] }
 
-  # sets console command when sample app initially opens
-  if Kernel.global_tick_count == 0
-    puts "* INFO - Please specify the number of sprites to render."
-    args.gtk.console.set_command "reset_with count: 100"
+  args.state.player[:cooldown] -= 1
+  if args.inputs.keyboard.key_held.space && args.state.player[:cooldown] <= 0 && args.state.player[:alive]
+    args.state.player_bullets << {x: args.state.player[:x] + 12, y: args.state.player[:y] + 28, w: 16, h: 16, path: 'sprites/star.png', dx: 0, dy: 8}.sprite
+    args.state.fired_shots       += 1
+    args.state.player[:cooldown] = 10 + 20 / args.state.wave
   end
-
-  # init
-  if args.state.tick_count == 0
-    args.state.stars = args.state.star_count.map { |i| new_star args }
+  args.state.enemies.each do |enemy|
+    if Math.rand < 0.0005 + 0.0005 * args.state.wave && args.state.player[:alive] && enemy[:move_state] == :normal
+      args.state.enemy_bullets << {x: enemy[:x] + 12, y: enemy[:y] - 8, w: 16, h: 16, path: 'sprites/star.png', dx: 0, dy: -3 - args.state.wave_root}.sprite
+    end
   end
 
-  # update
-  args.state.stars.each { |s| move_star args, s }
-
-  # render
-  args.outputs.sprites << args.state.stars
   args.outputs.background_color = [0, 0, 0]
-  args.outputs.primitives << args.gtk.current_framerate_primitives
+  args.outputs.primitives << args.state.enemies.map do |enemy|
+    [enemy[:x], enemy[:y], 40, 40, enemy[:path], -90].sprite
+  end
+  args.outputs.primitives << args.state.player if args.state.player[:alive]
+  args.outputs.primitives << args.state.explosions
+  args.outputs.primitives << args.state.player_bullets
+  args.outputs.primitives << args.state.enemy_bullets
+  accuracy = args.state.fired_shots.zero? ? 1 : (args.state.fired_shots - args.state.missed_shots) / args.state.fired_shots
+  args.outputs.primitives << [
+    [0, 0, 300, 720, 96, 0, 0].solid,
+    [1280 - 300, 0, 300, 720, 96, 0, 0].solid,
+    [1280 - 290, 60, "Wave     #{args.state.wave}", 255, 255, 255].label,
+    [1280 - 290, 40, "Accuracy #{(accuracy * 100).floor}%", 255, 255, 255].label,
+    [1280 - 290, 20, "Score    #{(args.state.score * accuracy).floor}", 255, 255, 255].label,
+  ]
+  args.outputs.primitives << args.state.lives.times.map do |n|
+    [1280 - 290 + 50 * n, 80, 40, 40, 'sprites/circle-gray.png', 90].sprite
+  end
+  #args.outputs.debug << args.gtk.framerate_diagnostics_primitives
+
+  if (!args.state.player[:alive]) && args.state.enemy_bullets.empty? && args.state.explosions.empty? && args.state.enemies.all? { |enemy| enemy[:move_state] == :normal }
+    args.state.player[:alive] = true
+    args.state.player[:x]     = 624
+    args.state.player[:y]     = 80
+    args.state.lives          -= 1
+    if args.state.lives == -1
+      args.state.clear!
+    end
+  end
+end
+
+def make_enemies
+  enemies = []
+  enemies += 10.times.map { |n| {x: Math.rand * 1280 * 2 - 640, y: Math.rand * 720 * 2 + 720, row: 0, col: n, path: 'sprites/circle-orange.png', move_state: :retreat} }
+  enemies += 10.times.map { |n| {x: Math.rand * 1280 * 2 - 640, y: Math.rand * 720 * 2 + 720, row: 1, col: n, path: 'sprites/circle-orange.png', move_state: :retreat} }
+  enemies += 8.times.map { |n| {x: Math.rand * 1280 * 2 - 640, y: Math.rand * 720 * 2 + 720, row: 2, col: n + 1, path: 'sprites/circle-blue.png', move_state: :retreat} }
+  enemies += 8.times.map { |n| {x: Math.rand * 1280 * 2 - 640, y: Math.rand * 720 * 2 + 720, row: 3, col: n + 1, path: 'sprites/circle-blue.png', move_state: :retreat} }
+  enemies += 4.times.map { |n| {x: Math.rand * 1280 * 2 - 640, y: Math.rand * 720 * 2 + 720, row: 4, col: n + 3, path: 'sprites/circle-green.png', move_state: :retreat} }
+  enemies
+end
+
+def update_explosions args
+  args.state.explosions.each do |explosion|
+    explosion[:age]  += 0.5
+    explosion[:path] = "sprites/explosion-#{explosion[:age].floor}.png"
+  end
+  args.state.explosions = args.state.explosions.reject { |explosion| explosion[:age] >= 7 }
+end
+
+def update_enemy_positions args
+  args.state.enemies.each do |enemy|
+    if enemy[:move_state] == :normal
+      enemy[:x]          = args.state.columns[enemy[:col]]
+      enemy[:y]          = args.state.rows[enemy[:row]]
+      enemy[:move_state] = :dive if Math.rand < 0.0002 + 0.00005 * args.state.wave && args.state.player[:alive]
+    elsif enemy[:move_state] == :dive
+      enemy[:target_x] ||= args.state.player[:x]
+      enemy[:target_y] ||= args.state.player[:y]
+      dx               = enemy[:target_x] - enemy[:x]
+      dy               = enemy[:target_y] - enemy[:y]
+      vel              = Math.sqrt(dx * dx + dy * dy)
+      speed_limit      = 2 + args.state.wave_root
+      if vel > speed_limit
+        dx /= vel / speed_limit
+        dy /= vel / speed_limit
+      end
+      if vel < 1 || !args.state.player[:alive]
+        enemy[:move_state] = :retreat
+      end
+      enemy[:x] += dx
+      enemy[:y] += dy
+    elsif enemy[:move_state] == :retreat
+      enemy[:target_x] = args.state.columns[enemy[:col]]
+      enemy[:target_y] = args.state.rows[enemy[:row]]
+      dx               = enemy[:target_x] - enemy[:x]
+      dy               = enemy[:target_y] - enemy[:y]
+      vel              = Math.sqrt(dx * dx + dy * dy)
+      speed_limit      = 2 + args.state.wave_root
+      if vel > speed_limit
+        dx /= vel / speed_limit
+        dy /= vel / speed_limit
+      elsif vel < 1
+        enemy[:move_state] = :normal
+        enemy[:target_x]   = nil
+        enemy[:target_y]   = nil
+      end
+      enemy[:x] += dx
+      enemy[:y] += dy
+    end
+  end
 end
 
-# resets game, and assigns star count given by user
-def reset_with count: count
-  $gtk.reset
-  $gtk.args.state.star_count = count
-end
+
+Arcade - Dueling Starships - main.rb
+# ./samples/99_genre_arcade/dueling_starships/app/main.rb
+class DuelingSpaceships
+  attr_accessor :state, :inputs, :outputs, :grid
 
-

-Performance - Sprites As Classes - main.rb
-# ./samples/09_performance/04_sprites_as_classes/app/main.rb
-# Sprites represented as Classes using the queue ~args.outputs.sprites~.
-# gives you full control of property declaration and method invocation.
-# They are more performant than OpenEntities and StrictEntities, but more code upfront.
-class Star
-  attr_sprite
+  def tick
+    defaults
+    render
+    calc
+    input
+  end
 
-  def initialize grid
-    @grid = grid
-    @x = (rand @grid.w) * -1
-    @y = (rand @grid.h) * -1
-    @w    = 4
-    @h    = 4
-    @s    = 1 + (4.randomize :ratio)
-    @path = 'sprites/tiny-star.png'
+  def defaults
+    outputs.background_color = [0, 0, 0]
+    state.ship_blue       ||= new_blue_ship
+    state.ship_red        ||= new_red_ship
+    state.flames          ||= []
+    state.bullets         ||= []
+    state.ship_blue_score ||= 0
+    state.ship_red_score  ||= 0
+    state.stars           ||= 100.map do
+      [rand.add(2).to_square(grid.w_half.randomize(:sign, :ratio),
+                             grid.h_half.randomize(:sign, :ratio)),
+       128 + 128.randomize(:ratio), 255, 255]
+    end
   end
 
-  def move
-    @x += @s
-    @y += @s
-    @x = (rand @grid.w) * -1 if @x > @grid.right
-    @y = (rand @grid.h) * -1 if @y > @grid.top
+  def default_ship x, y, angle, sprite_path, bullet_sprite_path, color
+    state.new_entity(:ship,
+                    { x: x,
+                      y: y,
+                      dy: 0,
+                      dx: 0,
+                      damage: 0,
+                      dead: false,
+                      angle: angle,
+                      max_alpha: 255,
+                      sprite_path: sprite_path,
+                      bullet_sprite_path: bullet_sprite_path,
+                      color: color })
   end
-end
 
-# calls methods needed for game to run properly
-def tick args
-  # sets console command when sample app initially opens
-  if Kernel.global_tick_count == 0
-    args.gtk.console.set_command "reset_with count: 100"
+  def new_red_ship
+    default_ship(400, 250.randomize(:sign, :ratio),
+                 180, 'sprites/ship_red.png', 'sprites/red_bullet.png',
+                 [255, 90, 90])
   end
 
-  # init
-  if args.state.tick_count == 0
-    args.state.stars = args.state.star_count.map { |i| Star.new args.grid }
+  def new_blue_ship
+    default_ship(-400, 250.randomize(:sign, :ratio),
+                 0, 'sprites/ship_blue.png', 'sprites/blue_bullet.png',
+                 [110, 140, 255])
   end
 
-  # update
-  args.state.stars.each(&:move)
+  def render
+    render_instructions
+    render_score
+    render_universe
+    render_flames
+    render_ships
+    render_bullets
+  end
 
-  # render
-  args.outputs.sprites << args.state.stars
-  args.outputs.background_color = [0, 0, 0]
-  args.outputs.primitives << args.gtk.current_framerate_primitives
-end
+  def render_ships
+    update_ship_outputs(state.ship_blue)
+    update_ship_outputs(state.ship_red)
+    outputs.sprites << [state.ship_blue.sprite, state.ship_red.sprite]
+    outputs.labels  << [state.ship_blue.label, state.ship_red.label]
+  end
 
-# resets game, and assigns star count given by user
-def reset_with count: count
-  $gtk.reset
-  $gtk.args.state.star_count = count
-end
+  def render_instructions
+    return if state.ship_blue.dx  > 0  || state.ship_blue.dy > 0  ||
+              state.ship_red.dx   > 0  || state.ship_red.dy  > 0  ||
+              state.flames.length > 0
 
-
-Performance - Static Sprites As Classes - main.rb
-# ./samples/09_performance/05_static_sprites_as_classes/app/main.rb
-# Sprites represented as Classes using the queue ~args.outputs.static_sprites~.
-# bypasses the queue behavior of ~args.outputs.sprites~. All instances are held
-# by reference. You get better performance, but you are mutating state of held objects
-# which is less functional/data oriented.
-class Star
-  attr_sprite
+    outputs.labels << [grid.left.shift_right(30),
+                       grid.bottom.shift_up(30),
+                       "Two gamepads needed to play. R1 to accelerate. Left and right on D-PAD to turn ship. Hold A to shoot. Press B to drop mines.",
+                       0, 0, 255, 255, 255]
+  end
 
-  def initialize grid
-    @grid = grid
-    @x = (rand @grid.w) * -1
-    @y = (rand @grid.h) * -1
-    @w    = 4
-    @h    = 4
-    @s    = 1 + (4.randomize :ratio)
-    @path = 'sprites/tiny-star.png'
+  def calc
+    calc_thrusts
+    calc_ships
+    calc_bullets
+    calc_winner
   end
 
-  def move
-    @x += @s
-    @y += @s
-    @x = (rand @grid.w) * -1 if @x > @grid.right
-    @y = (rand @grid.h) * -1 if @y > @grid.top
+  def input
+    input_accelerate
+    input_turn
+    input_bullets_and_mines
   end
-end
 
-# calls methods needed for game to run properly
-def tick args
-  # sets console command when sample app initially opens
-  if Kernel.global_tick_count == 0
-    args.gtk.console.set_command "reset_with count: 100"
+  def render_score
+    outputs.labels << [grid.left.shift_right(80),
+                       grid.top.shift_down(40),
+                       state.ship_blue_score, 30, 1, state.ship_blue.color]
+
+    outputs.labels << [grid.right.shift_left(80),
+                       grid.top.shift_down(40),
+                       state.ship_red_score,  30, 1, state.ship_red.color]
   end
 
-  # init
-  if args.state.tick_count == 0
-    args.state.stars = args.state.star_count.map { |i| Star.new args.grid }
+  def render_universe
+    return if outputs.static_solids.any?
+    outputs.static_solids << grid.rect
+    outputs.static_solids << state.stars
   end
 
-  # update
-  args.state.stars.each(&:move)
+  def apply_round_finished_alpha entity
+    return entity unless state.round_finished_debounce
+    entity.a *= state.round_finished_debounce.percentage_of(2.seconds)
+    return entity
+  end
 
-  # render
-  args.outputs.sprites << args.state.stars
-  args.outputs.background_color = [0, 0, 0]
-  args.outputs.primitives << args.gtk.current_framerate_primitives
-end
+  def update_ship_outputs ship, sprite_size = 66
+    ship.sprite =
+      apply_round_finished_alpha [sprite_size.to_square(ship.x, ship.y),
+                                  ship.sprite_path,
+                                  ship.angle,
+                                  ship.dead ? 0 : 255 * ship.created_at.ease(2.seconds)].sprite
+    ship.label =
+      apply_round_finished_alpha [ship.x,
+                                  ship.y + 100,
+                                  "." * 5.minus(ship.damage).greater(0), 20, 1, ship.color, 255].label
+  end
 
-# resets game, and assigns star count given by user
-def reset_with count: count
-  $gtk.reset
-  $gtk.args.state.star_count = count
-end
+  def render_flames sprite_size = 6
+    outputs.sprites << state.flames.map do |p|
+      apply_round_finished_alpha [sprite_size.to_square(p.x, p.y),
+                                  'sprites/flame.png', 0,
+                                  p.max_alpha * p.created_at.ease(p.lifetime, :flip)].sprite
+    end
+  end
 
-
-Performance - Static Sprites As Classes With Custom Drawing - main.rb
-# ./samples/09_performance/06_static_sprites_as_classes_with_custom_drawing/app/main.rb
-# Sprites represented as Classes, with a draw_override method, and using the queue ~args.outputs.static_sprites~.
-# is the fastest approach. This is comparable to what other game engines set as the default behavior.
-# There are tradeoffs for all this speed if the creation of a full blown class, and bypassing
-# functional/data-oriented practices.
-class Star
-  def initialize grid
-    @grid = grid
-    @x = (rand @grid.w) * -1
-    @y = (rand @grid.h) * -1
-    @w    = 4
-    @h    = 4
-    @s    = 1 + (4.randomize :ratio)
-    @path = 'sprites/tiny-star.png'
+  def render_bullets sprite_size = 10
+    outputs.sprites << state.bullets.map do |b|
+      apply_round_finished_alpha [b.sprite_size.to_square(b.x, b.y),
+                                  b.owner.bullet_sprite_path,
+                                  0, b.max_alpha].sprite
+    end
   end
 
-  def move
-    @x += @s
-    @y += @s
-    @x = (rand @grid.w) * -1 if @x > @grid.right
-    @y = (rand @grid.h) * -1 if @y > @grid.top
+  def wrap_location! location
+    location.x = grid.left    if location.x > grid.right
+    location.x = grid.right   if location.x < grid.left
+    location.y = grid.top     if location.y < grid.bottom
+    location.y = grid.bottom  if location.y > grid.top
+    location
   end
 
-  # if the object that is in args.outputs.sprites (or static_sprites)
-  # respond_to? :draw_override, then the method is invoked giving you
-  # access to the class used to draw to the canvas.
-  def draw_override ffi_draw
-    # first move then draw
-    move
-
-    # The argument order for ffi.draw_sprite is:
-    # x, y, w, h, path
-    ffi_draw.draw_sprite @x, @y, @w, @h, @path
+  def calc_thrusts
+    state.flames =
+      state.flames
+        .reject(&:old?)
+        .map do |p|
+          p.speed *= 0.9
+          p.y += p.angle.vector_y(p.speed)
+          p.x += p.angle.vector_x(p.speed)
+          wrap_location! p
+      end
+  end
 
-    # The argument order for ffi_draw.draw_sprite_2 is (pass in nil for default value):
-    # x, y, w, h, path,
-    # angle, alpha
+  def all_ships
+    [state.ship_blue, state.ship_red]
+  end
 
-    # The argument order for ffi_draw.draw_sprite_3 is:
-    # x, y, w, h,
-    # path,
-    # angle,
-    # alpha, red_saturation, green_saturation, blue_saturation
-    # flip_horizontally, flip_vertically,
-    # tile_x, tile_y, tile_w, tile_h
-    # angle_anchor_x, angle_anchor_y,
-    # source_x, source_y, source_w, source_h
+  def alive_ships
+    all_ships.reject { |s| s.dead }
   end
-end
 
-# calls methods needed for game to run properly
-def tick args
-  # sets console command when sample app initially opens
-  if Kernel.global_tick_count == 0
-    args.gtk.console.set_command "reset_with count: 100"
+  def calc_bullet bullet
+    bullet.y += bullet.angle.vector_y(bullet.speed)
+    bullet.x += bullet.angle.vector_x(bullet.speed)
+    wrap_location! bullet
+    explode_bullet! bullet if bullet.old?
+    return if bullet.exploded
+    return if state.round_finished
+    alive_ships.each do |s|
+      if s != bullet.owner &&
+         s.sprite.intersect_rect?(bullet.sprite_size.to_square(bullet.x, bullet.y))
+        explode_bullet! bullet, 10, 5, 30
+        s.damage += 1
+      end
+    end
   end
 
-  # init
-  if args.state.tick_count == 0
-    args.state.stars = args.state.star_count.map { |i| Star.new args.grid }
-    args.outputs.static_sprites << args.state.stars
+  def calc_bullets
+    state.bullets.each    { |b| calc_bullet b }
+    state.bullets.reject! { |b| b.exploded }
   end
 
-  # render framerate
-  args.outputs.background_color = [0, 0, 0]
-  args.outputs.primitives << args.gtk.current_framerate_primitives
-end
+  def create_explosion! type, entity, flame_count, max_speed, lifetime, max_alpha = 255
+    flame_count.times do
+      state.flames << state.new_entity(type,
+                                     { angle: 360.randomize(:ratio),
+                                       speed: max_speed.randomize(:ratio),
+                                       lifetime: lifetime,
+                                       x: entity.x,
+                                       y: entity.y,
+                                       max_alpha: max_alpha })
+    end
+  end
 
-# resets game, and assigns star count given by user
-def reset_with count: count
-  $gtk.reset
-  $gtk.args.state.star_count = count
-end
+  def explode_bullet! bullet, flame_override = 5, max_speed = 5, lifetime = 10
+    bullet.exploded = true
+    create_explosion! :bullet_explosion,
+                      bullet,
+                      flame_override,
+                      max_speed,
+                      lifetime,
+                      bullet.max_alpha
+  end
 
-
-Performance - Collision Limits - main.rb
-# ./samples/09_performance/07_collision_limits/app/main.rb
-=begin
+  def calc_ship ship
+    ship.x += ship.dx
+    ship.y += ship.dy
+    wrap_location! ship
+  end
 
- Reminders:
- - find_all: Finds all elements of a collection that meet certain requirements.
-   In this sample app, we're finding all bodies that intersect with the center body.
+  def calc_ships
+    all_ships.each { |s| calc_ship s }
+    return if all_ships.any? { |s| s.dead }
+    return if state.round_finished
+    return unless state.ship_blue.sprite.intersect_rect?(state.ship_red.sprite)
+    state.ship_blue.damage = 5
+    state.ship_red.damage  = 5
+  end
 
- - args.outputs.solids: An array. The values generate a solid.
-   The parameters are [X, Y, WIDTH, HEIGHT, RED, GREEN, BLUE]
-   For more information about solids, go to mygame/documentation/03-solids-and-borders.md.
+  def create_thruster_flames! ship
+    state.flames << state.new_entity(:ship_thruster,
+                                   { angle: ship.angle + 180 + 60.randomize(:sign, :ratio),
+                                     speed: 5.randomize(:ratio),
+                                     max_alpha: 255 * ship.created_at_elapsed.percentage_of(2.seconds),
+                                     lifetime: 30,
+                                     x: ship.x - ship.angle.vector_x(40) + 5.randomize(:sign, :ratio),
+                                     y: ship.y - ship.angle.vector_y(40) + 5.randomize(:sign, :ratio) })
+  end
 
- - args.outputs.labels: An array. The values generate a label.
-   The parameters are [X, Y, TEXT, SIZE, ALIGNMENT, RED, GREEN, BLUE, ALPHA, FONT STYLE]
-   For more information about labels, go to mygame/documentation/02-labels.md.
+  def input_accelerate_ship should_move_ship, ship
+    return if ship.dead
 
- - ARRAY#intersect_rect?: Returns true or false depending on if two rectangles intersect.
+    should_move_ship &&= (ship.dx + ship.dy).abs < 5
 
-=end
+    if should_move_ship
+      create_thruster_flames! ship
+      ship.dx += ship.angle.vector_x 0.050
+      ship.dy += ship.angle.vector_y 0.050
+    else
+      ship.dx *= 0.99
+      ship.dy *= 0.99
+    end
+  end
 
-# This code demonstrates moving objects that loop around once they exceed the scope of the screen,
-# which has dimensions of 1280 by 720, and also detects collisions between objects called "bodies".
+  def input_accelerate
+    input_accelerate_ship inputs.controller_one.key_held.r1 || inputs.keyboard.up, state.ship_blue
+    input_accelerate_ship inputs.controller_two.key_held.r1, state.ship_red
+  end
 
-def body_count num
-  $gtk.args.state.other_bodies = num.map { [1280 * rand, 720 * rand, 10, 10] } # other_bodies set using num collection
-end
+  def input_turn_ship direction, ship
+    ship.angle -= 3 * direction
+  end
 
-def tick args
+  def input_turn
+    input_turn_ship inputs.controller_one.left_right + inputs.keyboard.left_right, state.ship_blue
+    input_turn_ship inputs.controller_two.left_right, state.ship_red
+  end
 
-  # Center body's values are set using an array
-  # Map is used to set values of 2000 other bodies
-  # All bodies that intersect with center body are stored in collisions collection
-  args.state.center_body  ||= [640 - 100, 360 - 100, 200, 200] # calculations done to place body in center
-  args.state.other_bodies ||= 2000.map { [1280 * rand, 720 * rand, 10, 10] } # 2000 bodies given random position on screen
+  def input_bullet create_bullet, ship
+    return unless create_bullet
+    return if ship.dead
 
-  # finds all bodies that intersect with center body, stores them in collisions
-  collisions = args.state.other_bodies.find_all { |b| b.intersect_rect? args.state.center_body }
+    state.bullets << state.new_entity(:ship_bullet,
+                                    { owner: ship,
+                                      angle: ship.angle,
+                                      max_alpha: 255 * ship.created_at_elapsed.percentage_of(2.seconds),
+                                      speed: 5 + ship.dx.mult(ship.angle.vector_x) + ship.dy.mult(ship.angle.vector_y),
+                                      lifetime: 120,
+                                      sprite_size: 10,
+                                      x: ship.x + ship.angle.vector_x * 32,
+                                      y: ship.y + ship.angle.vector_y * 32 })
+  end
 
-  args.borders << args.state.center_body # outputs center body as a black border
+  def input_mine create_mine, ship
+    return unless create_mine
+    return if ship.dead
 
-  # transparency changes based on number of collisions; the more collisions, the redder (more transparent) the box becomes
-  args.solids  << [args.state.center_body, 255, 0, 0, collisions.length * 5] # center body is red solid
-  args.solids  << args.state.other_bodies # other bodies are output as (black) solids, as well
+    state.bullets << state.new_entity(:ship_bullet,
+                                    { owner: ship,
+                                      angle: 360.randomize(:sign, :ratio),
+                                      max_alpha: 255 * ship.created_at_elapsed.percentage_of(2.seconds),
+                                      speed: 0.02,
+                                      sprite_size: 10,
+                                      lifetime: 600,
+                                      x: ship.x + ship.angle.vector_x * -50,
+                                      y: ship.y + ship.angle.vector_y * -50 })
+  end
 
-  args.labels  << [10, 30, args.gtk.current_framerate] # outputs frame rate in bottom left corner
+  def input_bullets_and_mines
+    return if state.bullets.length > 100
 
-  # Bodies are returned to bottom left corner if positions exceed scope of screen
-  args.state.other_bodies.each do |b| # for each body in the other_bodies collection
-    b.x += 5 # x and y are both incremented by 5
-    b.y += 5
-    b.x = 0 if b.x > 1280 # x becomes 0 if star exceeds scope of screen (goes too far right)
-    b.y = 0 if b.y > 720 # y becomes 0 if star exceeds scope of screen (goes too far up)
+    [
+      [inputs.controller_one.key_held.a || inputs.keyboard.key_held.space,
+       inputs.controller_one.key_down.b || inputs.keyboard.key_down.down,
+       state.ship_blue],
+      [inputs.controller_two.key_held.a, inputs.controller_two.key_down.b, state.ship_red]
+    ].each do |a_held, b_down, ship|
+      input_bullet(a_held && state.tick_count.mod_zero?(10).or(a_held == 0), ship)
+      input_mine(b_down, ship)
+    end
   end
-end
 
-# Resets the game.
-$gtk.reset
+  def calc_kill_ships
+    alive_ships.find_all { |s| s.damage >= 5 }.each do |s|
+      s.dead = true
+      create_explosion! :ship_explosion, s, 20, 20, 30, s.max_alpha
+    end
+  end
 
-
-Advanced Debugging - Trace Debugging - main.rb
-# ./samples/10_advanced_debugging/01_trace_debugging/app/main.rb
-class Game
-  attr_gtk
+  def calc_score
+    return if state.round_finished
+    return if alive_ships.length > 1
 
-  def method1 num
-    method2 num
-  end
+    if alive_ships.first == state.ship_red
+      state.ship_red_score += 1
+    elsif alive_ships.first == state.ship_blue
+      state.ship_blue_score += 1
+    end
 
-  def method2 num
-    method3 num
+    state.round_finished = true
   end
 
-  def method3 num
-    method4 num
+  def calc_reset_ships
+    return unless state.round_finished
+    state.round_finished_debounce ||= 2.seconds
+    state.round_finished_debounce -= 1
+    return if state.round_finished_debounce > 0
+    start_new_round!
   end
 
-  def method4 num
-    if num == 1
-      puts "UNLUCKY #{num}."
-      state.unlucky_count += 1
-      if state.unlucky_count > 3
-        raise "NAT 1 finally occurred. Check app/trace.txt for all method invocation history."
-      end
-    else
-      puts "LUCKY #{num}."
-    end
+  def start_new_round!
+    state.ship_blue = new_blue_ship
+    state.ship_red  = new_red_ship
+    state.round_finished = false
+    state.round_finished_debounce = nil
+    state.flames.clear
+    state.bullets.clear
   end
 
-  def tick
-    state.roll_history ||= []
-    state.roll_history << rand(20) + 1
-    state.countdown ||= 600
-    state.countdown  -= 1
-    state.unlucky_count ||= 0
-    outputs.labels << [640, 360, "A dice roll of 1 will cause an exception.", 0, 1]
-    if state.countdown > 0
-      outputs.labels << [640, 340, "Dice roll countdown: #{state.countdown}", 0, 1]
-    else
-      state.attempts ||= 0
-      state.attempts  += 1
-      outputs.labels << [640, 340, "ROLLING! #{state.attempts}", 0, 1]
-    end
-    return if state.countdown > 0
-    method1 state.roll_history[-1]
+  def calc_winner
+    calc_kill_ships
+    calc_score
+    calc_reset_ships
   end
 end
 
-$game = Game.new
+$dueling_spaceship = DuelingSpaceships.new
 
 def tick args
-  trace! $game # <------------------- TRACING ENABLED FOR THIS OBJECT
-  $game.args = args
-  $game.tick
+  args.grid.origin_center!
+  $dueling_spaceship.inputs  = args.inputs
+  $dueling_spaceship.outputs = args.outputs
+  $dueling_spaceship.state    = args.state
+  $dueling_spaceship.grid    = args.grid
+  $dueling_spaceship.tick
 end
 
-
-Advanced Debugging - Trace Debugging Classes - main.rb
-# ./samples/10_advanced_debugging/02_trace_debugging_classes/app/main.rb
-class Foobar
-  def initialize
-    trace! # Trace is added to the constructor.
-  end
+
+arcade/flappy dragon/credits.txt
+# ./samples/99_genre_arcade/flappy_dragon/CREDITS.txt
+code: Amir Rajan, https://twitter.com/amirrajan
+graphics and audio: Nick Culbertson, https://twitter.com/MobyPixel
 
-  def clicky args
-    return unless args.inputs.mouse.click
-    try_rand rand
+
+
+arcade/flappy dragon/main.rb
+# ./samples/99_genre_arcade/flappy_dragon/app/main.rb
+class FlappyDragon
+  attr_accessor :grid, :inputs, :state, :outputs
+
+  def tick
+    defaults
+    render
+    calc
+    process_inputs
   end
 
-  def try_rand num
-    return if num < 0.9
-    raise "Exception finally occurred. Take a look at logs/trace.txt #{num}."
+  def defaults
+    state.flap_power              = 11
+    state.gravity                 = 0.9
+    state.ceiling                 = 600
+    state.ceiling_flap_power      = 6
+    state.wall_countdown_length   = 100
+    state.wall_gap_size           = 100
+    state.wall_countdown        ||= 0
+    state.hi_score              ||= 0
+    state.score                 ||= 0
+    state.walls                 ||= []
+    state.x                     ||= 50
+    state.y                     ||= 500
+    state.dy                    ||= 0
+    state.scene                 ||= :menu
+    state.scene_at              ||= 0
+    state.difficulty            ||= :normal
+    state.new_difficulty        ||= :normal
+    state.countdown             ||= 4.seconds
+    state.flash_at              ||= 0
   end
-end
 
-def tick args
-  args.labels << [640, 360, "Start clicking. Eventually an exception will be thrown. Then look at logs/trace.txt.", 0, 1]
-  args.state.foobar = Foobar.new if args.tick_count
-  return unless args.state.foobar
-  args.state.foobar.clicky args
-end
+  def render
+    outputs.sounds << "sounds/flappy-song.ogg" if state.tick_count == 1
+    render_score
+    render_menu
+    render_game
+  end
 
-

-Advanced Debugging - Unit Tests - exception_raising_tests.rb
-# ./samples/10_advanced_debugging/03_unit_tests/exception_raising_tests.rb
-begin :shared
-  class ExceptionalClass
-    def initialize exception_to_throw = nil
-      raise exception_to_throw if exception_to_throw
-    end
+  def render_score
+    outputs.primitives << [10, 710, "HI SCORE: #{state.hi_score}", large_white_typeset].label
+    outputs.primitives << [10, 680, "SCORE: #{state.score}", large_white_typeset].label
+    outputs.primitives << [10, 650, "DIFFICULTY: #{state.difficulty.upcase}", large_white_typeset].label
   end
-end
 
-def test_exception_in_newing_object args, assert
-  begin
-    ExceptionalClass.new TypeError
-    raise "Exception wasn't thrown!"
-  rescue Exception => e
-    assert.equal! e.class, TypeError, "Exceptions within constructor should be retained."
+  def render_menu
+    return unless state.scene == :menu
+    render_overlay
+
+    outputs.labels << [640, 700, "Flappy Dragon", 50, 1, 255, 255, 255]
+    outputs.labels << [640, 500, "Instructions: Press Spacebar to flap. Don't die.", 4, 1, 255, 255, 255]
+    outputs.labels << [430, 430, "[Tab]    Change difficulty", 4, 0, 255, 255, 255]
+    outputs.labels << [430, 400, "[Enter]  Start at New Difficulty ", 4, 0, 255, 255, 255]
+    outputs.labels << [430, 370, "[Escape] Cancel/Resume ", 4, 0, 255, 255, 255]
+    outputs.labels << [640, 300, "(mouse, touch, and game controllers work, too!) ", 4, 1, 255, 255, 255]
+    outputs.labels << [640, 200, "Difficulty: #{state.new_difficulty.capitalize}", 4, 1, 255, 255, 255]
+
+    outputs.labels << [10, 100, "Code:   @amirrajan",     255, 255, 255]
+    outputs.labels << [10,  80, "Art:    @mobypixel",     255, 255, 255]
+    outputs.labels << [10,  60, "Music:  @mobypixel",     255, 255, 255]
+    outputs.labels << [10,  40, "Engine: DragonRuby GTK", 255, 255, 255]
   end
-end
 
-puts "running tests"
-$gtk.reset 100
-$gtk.log_level = :off
-$gtk.tests.start
+  def render_overlay
+    outputs.primitives << [grid.rect.scale_rect(1.1, 0, 0), 0, 0, 0, 230].solid
+  end
 
-
-Advanced Debugging - Unit Tests - gen_docs.rb
-# ./samples/10_advanced_debugging/03_unit_tests/gen_docs.rb
-# sh ./amir-build-and-run.sh --eval samples/99_zz_gtk_unit_tests/gen_docs.rb --no-tick
-Kernel.export_docs!
+  def render_game
+    render_game_over
+    render_background
+    render_walls
+    render_dragon
+    render_flash
+  end
 
-
-Advanced Debugging - Unit Tests - geometry_tests.rb
-# ./samples/10_advanced_debugging/03_unit_tests/geometry_tests.rb
-begin :shared
-  def primitive_representations x, y, w, h
-    [
-      [x, y, w, h],
-      { x: x, y: y, w: w, h: h },
-      RectForTest.new(x, y, w, h)
-    ]
+  def render_game_over
+    return unless state.scene == :game
+    outputs.labels << [638, 358, score_text, 20, 1]
+    outputs.labels << [635, 360, score_text, 20, 1, 255, 255, 255]
+    outputs.labels << [638, 428, countdown_text, 20, 1]
+    outputs.labels << [635, 430, countdown_text, 20, 1, 255, 255, 255]
   end
 
-  class RectForTest
-    attr_sprite
+  def render_background
+    outputs.sprites << [0, 0, 1280, 720, 'sprites/background.png']
 
-    def initialize x, y, w, h
-      @x = x
-      @y = y
-      @w = w
-      @h = h
-    end
+    scroll_point_at   = state.tick_count
+    scroll_point_at   = state.scene_at if state.scene == :menu
+    scroll_point_at   = state.death_at if state.countdown > 0
+    scroll_point_at ||= 0
 
-    def to_s
-      "RectForTest: #{[x, y, w, h]}"
-    end
+    outputs.sprites << scrolling_background(scroll_point_at, 'sprites/parallax_back.png',   0.25)
+    outputs.sprites << scrolling_background(scroll_point_at, 'sprites/parallax_middle.png', 0.50)
+    outputs.sprites << scrolling_background(scroll_point_at, 'sprites/parallax_front.png',  1.00, -80)
   end
-end
 
-begin :intersect_rect?
-  def test_intersect_rect_point args, assert
-    assert.true! [16, 13].intersect_rect?([13, 12, 4, 4]), "point intersects with rect."
+  def render_walls
+    state.walls.each do |w|
+      w.sprites = [
+        [w.x, w.bottom_height - 720, 100, 720, 'sprites/wall.png', 180],
+        [w.x, w.top_y,               100, 720, 'sprites/wallbottom.png', 0]
+      ]
+    end
+    outputs.sprites << state.walls.map(&:sprites)
   end
 
-  def test_intersect_rect args, assert
-    intersecting = primitive_representations(0, 0, 100, 100) +
-                   primitive_representations(20, 20, 20, 20)
+  def render_dragon
+    state.show_death = true if state.countdown == 3.seconds
 
-    intersecting.product(intersecting).each do |rect_one, rect_two|
-      assert.true! rect_one.intersect_rect?(rect_two),
-                   "intersect_rect? assertion failed for #{rect_one}, #{rect_two} (expected true)."
+    render_debug_hitbox false
+
+    if state.show_death == false || !state.death_at
+      animation_index = state.flapped_at.frame_index 6, 2, false if state.flapped_at
+      sprite_name = "sprites/dragon_fly#{animation_index.or(0) + 1}.png"
+      state.dragon_sprite = [state.x, state.y, 100, 80, sprite_name, state.dy * 1.2]
+    else
+      sprite_name = "sprites/dragon_die.png"
+      state.dragon_sprite = [state.x, state.y, 100, 80, sprite_name, state.dy * 1.2]
+      sprite_changed_elapsed    = state.death_at.elapsed_time - 1.seconds
+      state.dragon_sprite.angle += (sprite_changed_elapsed ** 1.3) * state.death_fall_direction * -1
+      state.dragon_sprite.x     += (sprite_changed_elapsed ** 1.2) * state.death_fall_direction
+      state.dragon_sprite.y     += (sprite_changed_elapsed * 14 - sprite_changed_elapsed ** 1.6)
     end
 
-    not_intersecting = [
-      [ 0, 0, 5, 5],
-      { x: 10, y: 10, w: 5, h: 5 },
-      RectForTest.new(20, 20, 5, 5)
-    ]
+    outputs.sprites << state.dragon_sprite
+  end
 
-    not_intersecting.product(not_intersecting)
-      .reject { |rect_one, rect_two| rect_one == rect_two }
-      .each do |rect_one, rect_two|
-      assert.false! rect_one.intersect_rect?(rect_two),
-                    "intersect_rect? assertion failed for #{rect_one}, #{rect_two} (expected false)."
+  def render_debug_hitbox show
+    return unless show
+    outputs.borders << [dragon_collision_box.rect, 255, 0, 0] if state.dragon_sprite
+    outputs.borders << state.walls.flat_map do |w|
+       w.sprites.map { |s| [s.rect, 255, 0, 0] }
     end
   end
-end
 
-begin :inside_rect?
-  def assert_inside_rect outer: nil, inner: nil, expected: nil, assert: nil
-    assert.true! inner.inside_rect?(outer) == expected,
-                 "inside_rect? assertion failed for outer: #{outer} inner: #{inner} (expected #{expected})."
-  end
+  def render_flash
+    return unless state.flash_at
 
-  def test_inside_rect args, assert
-    outer_rects = primitive_representations(0, 0, 10, 10)
-    inner_rects = primitive_representations(1, 1, 5, 5)
-    primitive_representations(0, 0, 10, 10).product(primitive_representations(1, 1, 5, 5))
-      .each do |outer, inner|
-      assert_inside_rect outer: outer, inner: inner,
-                         expected: true, assert: assert
-    end
+    outputs.primitives << [grid.rect,
+                           white,
+                           255 * state.flash_at.ease(20, :flip)].solid
+
+    state.flash_at = 0 if state.flash_at.elapsed_time > 20
   end
-end
 
-begin :angle_to
-  def test_angle_to args, assert
-    origins = primitive_representations(0, 0, 0, 0)
-    rights = primitive_representations(1, 0, 0, 0)
-    aboves = primitive_representations(0, 1, 0, 0)
+  def calc
+    return unless state.scene == :game
+    reset_game if state.countdown == 1
+    state.countdown -= 1 and return if state.countdown > 0
+    calc_walls
+    calc_flap
+    calc_game_over
+  end
 
-    origins.product(aboves).each do |origin, above|
-      assert.equal! origin.angle_to(above), 90,
-                    "A point directly above should be 90 degrees."
+  def calc_walls
+    state.walls.each { |w| w.x -= 8 }
 
-      assert.equal! above.angle_from(origin), 90,
-                    "A point coming from above should be 90 degrees."
-    end
+    walls_count_before_removal = state.walls.length
 
-    origins.product(rights).each do |origin, right|
-      assert.equal! origin.angle_to(right) % 360, 0,
-                    "A point directly to the right should be 0 degrees."
+    state.walls.reject! { |w| w.x < -100 }
 
-      assert.equal! right.angle_from(origin) % 360, 0,
-                    "A point coming from the right should be 0 degrees."
+    state.score += 1 if state.walls.count < walls_count_before_removal
+
+    state.wall_countdown -= 1 and return if state.wall_countdown > 0
 
+    state.walls << state.new_entity(:wall) do |w|
+      w.x             = grid.right
+      w.opening       = grid.top
+                            .randomize(:ratio)
+                            .greater(200)
+                            .lesser(520)
+      w.bottom_height = w.opening - state.wall_gap_size
+      w.top_y         = w.opening + state.wall_gap_size
     end
+
+    state.wall_countdown = state.wall_countdown_length
   end
-end
 
-begin :scale_rect
-  def test_scale_rect args, assert
-    assert.equal! [0, 0, 100, 100].scale_rect(0.5, 0.5),
-                  [25.0, 25.0, 50.0, 50.0]
+  def calc_flap
+    state.y += state.dy
+    state.dy = state.dy.lesser state.flap_power
+    state.dy -= state.gravity
+    return if state.y < state.ceiling
+    state.y  = state.ceiling
+    state.dy = state.dy.lesser state.ceiling_flap_power
+  end
 
-    assert.equal! [0, 0, 100, 100].scale_rect(0.5),
-                  [0.0, 0.0, 50.0, 50.0]
+  def calc_game_over
+    return unless game_over?
 
-    assert.equal! [0, 0, 100, 100].scale_rect_extended(percentage_x: 0.5, percentage_y: 0.5, anchor_x: 0.5, anchor_y: 0.5),
-                  [25.0, 25.0, 50.0, 50.0]
+    state.death_at = state.tick_count
+    state.death_from = state.walls.first
+    state.death_fall_direction = -1
+    state.death_fall_direction =  1 if state.x > state.death_from.x
+    outputs.sounds << "sounds/hit-sound.wav"
+    begin_countdown
+  end
 
-    assert.equal! [0, 0, 100, 100].scale_rect_extended(percentage_x: 0.5, percentage_y: 0.5, anchor_x: 0, anchor_y: 0),
-                  [0.0, 0.0, 50.0, 50.0]
+  def process_inputs
+    process_inputs_menu
+    process_inputs_game
   end
-end
 
-puts "running tests"
-$gtk.reset 100
-$gtk.log_level = :off
-$gtk.tests.start
+  def process_inputs_menu
+    return unless state.scene == :menu
 
-
-Advanced Debugging - Unit Tests - http_tests.rb
-# ./samples/10_advanced_debugging/03_unit_tests/http_tests.rb
-def try_assert_or_schedule args, assert
-  if $result[:complete]
-    log_info "Request completed! Verifying."
-    if $result[:http_response_code] != 200
-      log_info "The request yielded a result of #{$result[:http_response_code]} instead of 200."
-      exit
+    changediff = inputs.keyboard.key_down.tab || inputs.controller_one.key_down.select
+    if inputs.mouse.click
+      p = inputs.mouse.click.point
+      if (p.y >= 165) && (p.y < 200) && (p.x >= 500) && (p.x < 800)
+        changediff = true
+      end
     end
-    log_info ":try_assert_or_schedule succeeded!"
-  else
-    args.gtk.schedule_callback Kernel.tick_count + 10 do
-      try_assert_or_schedule args, assert
+
+    if changediff
+      case state.new_difficulty
+      when :easy
+        state.new_difficulty = :normal
+      when :normal
+        state.new_difficulty = :hard
+      when :hard
+        state.new_difficulty = :flappy
+      when :flappy
+        state.new_difficulty = :easy
+      end
     end
-  end
-end
 
-def test_http args, assert
-  $result = $gtk.http_get 'http://dragonruby.org'
-  try_assert_or_schedule args, assert
-end
+    if inputs.keyboard.key_down.enter || inputs.controller_one.key_down.start || inputs.controller_one.key_down.a
+      state.difficulty = state.new_difficulty
+      change_to_scene :game
+      reset_game false
+      state.hi_score = 0
+      begin_countdown
+    end
 
-puts "running tests"
-$gtk.reset 100
-$gtk.log_level = :off
-$gtk.tests.start
+    if inputs.keyboard.key_down.escape || (inputs.mouse.click && !changediff) || inputs.controller_one.key_down.b
+      state.new_difficulty = state.difficulty
+      change_to_scene :game
+    end
+  end
 
-
-Advanced Debugging - Unit Tests - object_to_primitive_tests.rb
-# ./samples/10_advanced_debugging/03_unit_tests/object_to_primitive_tests.rb
-class PlayerSpriteForTest
-end
+  def process_inputs_game
+    return unless state.scene == :game
 
-def test_array_to_sprite args, assert
-  array = [[0, 0, 100, 100, "test.png"]].sprites
-  puts "No exception was thrown. Sweet!"
-end
+    clicked_menu = false
+    if inputs.mouse.click
+      p = inputs.mouse.click.point
+      clicked_menu = (p.y >= 620) && (p.x < 275)
+    end
 
-def test_class_to_sprite args, assert
-  array = [PlayerSprite.new].sprites
-  assert.true! array.first.is_a?(PlayerSprite)
-  puts "No exception was thrown. Sweet!"
-end
+    if clicked_menu || inputs.keyboard.key_down.escape || inputs.keyboard.key_down.enter || inputs.controller_one.key_down.start
+      change_to_scene :menu
+    elsif (inputs.mouse.down || inputs.mouse.click || inputs.keyboard.key_down.space || inputs.controller_one.key_down.a) && state.countdown == 0
+      state.dy = 0
+      state.dy += state.flap_power
+      state.flapped_at = state.tick_count
+      outputs.sounds << "sounds/fly-sound.wav"
+    end
+  end
 
-$gtk.reset 100
-$gtk.log_level = :off
-$gtk.tests.start
+  def scrolling_background at, path, rate, y = 0
+    [
+      [   0 - at.*(rate) % 1440, y, 1440, 720, path],
+      [1440 - at.*(rate) % 1440, y, 1440, 720, path]
+    ]
+  end
 
-
-Advanced Debugging - Unit Tests - parsing_tests.rb
-# ./samples/10_advanced_debugging/03_unit_tests/parsing_tests.rb
-def test_parse_json args, assert
-  result = args.gtk.parse_json '{ "name": "John Doe", "aliases": ["JD"] }'
-  assert.equal! result, { "name"=>"John Doe", "aliases"=>["JD"] }, "Parsing JSON failed."
-end
+  def white
+    [255, 255, 255]
+  end
 
-def test_parse_xml args, assert
-  result = args.gtk.parse_xml <<-S
-
-  John Doe
-
-S
+  def large_white_typeset
+    [5, 0, 255, 255, 255]
+  end
 
- expected = {:type=>:element,
-             :name=>nil,
-             :children=>[{:type=>:element,
-                          :name=>"Person",
-                          :children=>[{:type=>:element,
-                                       :name=>"Name",
-                                       :children=>[{:type=>:content,
-                                                    :data=>"John Doe"}]}],
-                          :attributes=>{"id"=>"100"}}]}
+  def at_beginning?
+    state.walls.count == 0
+  end
 
- assert.equal! result, expected, "Parsing xml failed."
-end
+  def dragon_collision_box
+    state.dragon_sprite
+        .scale_rect(1.0 - collision_forgiveness, 0.5, 0.5)
+        .rect_shift_right(10)
+        .rect_shift_up(state.dy * 2)
+  end
 
-puts "running tests"
-$gtk.reset 100
-$gtk.log_level = :off
-$gtk.tests.start
+  def game_over?
+    return true if state.y <= 0.-(500 * collision_forgiveness) && !at_beginning?
 
-
-Advanced Debugging - Unit Tests - serialize_deserialize_tests.rb
-# ./samples/10_advanced_debugging/03_unit_tests/serialize_deserialize_tests.rb
-def test_serialize args, assert
-  GTK::Entity.__reset_id__!
-  args.state.player_one = "test"
-  result = args.gtk.serialize_state args.state
-  assert.equal! result, "{:entity_id=>3, :entity_keys_by_ref=>{}, :tick_count=>-1, :player_one=>\"test\"}"
+    state.walls
+        .flat_map { |w| w.sprites }
+        .any? do |s|
+          s.intersect_rect?(dragon_collision_box)
+        end
+  end
 
-  GTK::Entity.__reset_id__!
-  args.gtk.write_file 'state.txt', ''
-  result = args.gtk.serialize_state 'state.txt', args.state
-  assert.equal! result, "{:entity_id=>3, :entity_keys_by_ref=>{}, :tick_count=>-1, :player_one=>\"test\"}"
-end
+  def collision_forgiveness
+    case state.difficulty
+    when :easy
+      0.9
+    when :normal
+      0.7
+    when :hard
+      0.5
+    when :flappy
+      0.3
+    else
+      0.9
+    end
+  end
 
-def test_deserialize args, assert
-  GTK::Entity.__reset_id__!
-  result = args.gtk.deserialize_state '{:entity_id=>3, :tick_count=>-1, :player_one=>"test"}'
-  assert.equal! result.player_one, "test"
+  def countdown_text
+    state.countdown ||= -1
+    return ""          if state.countdown == 0
+    return "GO!"       if state.countdown.idiv(60) == 0
+    return "GAME OVER" if state.death_at
+    return "READY?"
+  end
 
-  GTK::Entity.__reset_id__!
-  args.gtk.write_file 'state.txt',  '{:entity_id=>3, :tick_count=>-1, :player_one=>"test"}'
-  result = args.gtk.deserialize_state 'state.txt'
-  assert.equal! result.player_one, "test"
-end
+  def begin_countdown
+    state.countdown = 4.seconds
+  end
 
-def test_very_large_serialization args, assert
-  GTK::Entity.__reset_id__!
-  size = 3000
-  size.map_with_index do |i|
-    args.state.send("k#{i}=".to_sym, i)
+  def score_text
+    return ""                        unless state.countdown > 1.seconds
+    return ""                        unless state.death_at
+    return "SCORE: 0 (LOL)"          if state.score == 0
+    return "HI SCORE: #{state.score}" if state.score == state.hi_score
+    return "SCORE: #{state.score}"
+  end
+
+  def reset_game set_flash = true
+    state.flash_at = state.tick_count if set_flash
+    state.walls = []
+    state.y = 500
+    state.dy = 0
+    state.hi_score = state.hi_score.greater(state.score)
+    state.score = 0
+    state.wall_countdown = state.wall_countdown_length.fdiv(2)
+    state.show_death = false
+    state.death_at = nil
   end
 
-  result = args.gtk.serialize_state args.state
-  assert.true! (args.gtk.console.log.join.include? "unlikely a string this large will deserialize correctly")
+  def change_to_scene scene
+    state.scene = scene
+    state.scene_at = state.tick_count
+    inputs.keyboard.clear
+    inputs.controller_one.clear
+  end
 end
 
-def test_strict_entity_serialization args, assert
-  GTK::Entity.__reset_id__!
-  args.state.player_one = args.state.new_entity(:player, name: "Ryu")
-  args.state.player_two = args.state.new_entity_strict(:player_strict, name: "Ken")
+$flappy_dragon = FlappyDragon.new
 
-  serialized_state = args.gtk.serialize_state args.state
-  assert.equal! serialized_state, '{:entity_id=>1, :entity_keys_by_ref=>{}, :tick_count=>-1, :player_one=>{:entity_id=>1, :entity_name=>:player, :entity_keys_by_ref=>{}, :entity_type=>:player, :created_at=>-1, :global_created_at=>-1, :name=>"Ryu"}, :player_two=>{:entity_id=>3, :entity_name=>:player_strict, :entity_type=>:player_strict, :created_at=>-1, :global_created_at_elapsed=>-1, :entity_strict=>true, :entity_keys_by_ref=>{:entity_type=>:entity_name, :global_created_at_elapsed=>:created_at}, :name=>"Ken"}}'
+def tick args
+  $flappy_dragon.grid = args.grid
+  $flappy_dragon.inputs = args.inputs
+  $flappy_dragon.state = args.state
+  $flappy_dragon.outputs = args.outputs
+  $flappy_dragon.tick
+end
 
-  GTK::Entity.__reset_id__!
-  deserialize_state = args.gtk.deserialize_state serialized_state
+
+Arcade - Pong - main.rb
+# ./samples/99_genre_arcade/pong/app/main.rb
+def tick args
+  defaults args
+  render args
+  calc args
+  input args
+end
 
-  assert.equal! args.state.player_one.name, deserialize_state.player_one.name
-  assert.true! args.state.player_one.is_a? GTK::OpenEntity
+def defaults args
+  args.state.ball.debounce       ||= 3 * 60
+  args.state.ball.size           ||= 10
+  args.state.ball.size_half      ||= args.state.ball.size / 2
+  args.state.ball.x              ||= 640
+  args.state.ball.y              ||= 360
+  args.state.ball.dx             ||= 5.randomize(:sign)
+  args.state.ball.dy             ||= 5.randomize(:sign)
+  args.state.left_paddle.y       ||= 360
+  args.state.right_paddle.y      ||= 360
+  args.state.paddle.h            ||= 120
+  args.state.paddle.w            ||= 10
+  args.state.left_paddle.score   ||= 0
+  args.state.right_paddle.score  ||= 0
+end
 
-  assert.equal! args.state.player_two.name, deserialize_state.player_two.name
-  assert.true! args.state.player_two.is_a? GTK::StrictEntity
+def render args
+  render_center_line args
+  render_scores args
+  render_countdown args
+  render_ball args
+  render_paddles args
+  render_instructions args
 end
 
-def test_strict_entity_serialization_with_nil args, assert
-  GTK::Entity.__reset_id__!
-  args.state.player_one = args.state.new_entity(:player, name: "Ryu")
-  args.state.player_two = args.state.new_entity_strict(:player_strict, name: "Ken", blood_type: nil)
+begin :render_methods
+  def render_center_line args
+    args.outputs.lines  << [640, 0, 640, 720]
+  end
 
-  serialized_state = args.gtk.serialize_state args.state
-  assert.equal! serialized_state, '{:entity_id=>9, :entity_keys_by_ref=>{}, :tick_count=>-1, :player_one=>{:entity_id=>1, :entity_name=>:player, :entity_keys_by_ref=>{}, :entity_type=>:player, :created_at=>-1, :global_created_at=>-1, :name=>"Ryu"}, :player_two=>{:entity_id=>2, :entity_name=>:player_strict, :entity_type=>:player_strict, :created_at=>-1, :global_created_at_elapsed=>-1, :entity_strict=>true, :entity_keys_by_ref=>{:entity_type=>:entity_name, :global_created_at_elapsed=>:created_at}, :name=>"Ken", :blood_type=>nil}}'
+  def render_scores args
+    args.outputs.labels << [
+      [320, 650, args.state.left_paddle.score, 10, 1],
+      [960, 650, args.state.right_paddle.score, 10, 1]
+    ]
+  end
 
-  GTK::Entity.__reset_id__!
-  deserialized_state = args.gtk.deserialize_state serialized_state
+  def render_countdown args
+    return unless args.state.ball.debounce > 0
+    args.outputs.labels << [640, 360, "%.2f" % args.state.ball.debounce.fdiv(60), 10, 1]
+  end
 
-  assert.equal! args.state.player_one.name, deserialized_state.player_one.name
-  assert.true! args.state.player_one.is_a? GTK::OpenEntity
+  def render_ball args
+    args.outputs.solids << solid_ball(args)
+  end
 
-  assert.equal! args.state.player_two.name, deserialized_state.player_two.name
-  assert.equal! args.state.player_two.blood_type, deserialized_state.player_two.blood_type
-  assert.equal! deserialized_state.player_two.blood_type, nil
-  assert.true! args.state.player_two.is_a? GTK::StrictEntity
+  def render_paddles args
+    args.outputs.solids << solid_left_paddle(args)
+    args.outputs.solids << solid_right_paddle(args)
+  end
 
-  deserialized_state.player_two.blood_type = :O
-  assert.equal! deserialized_state.player_two.blood_type, :O
+  def render_instructions args
+    args.outputs.labels << [320, 30, "W and S keys to move left paddle.",  0, 1]
+    args.outputs.labels << [920, 30, "O and L keys to move right paddle.", 0, 1]
+  end
 end
 
-def test_multiple_strict_entities args, assert
-  GTK::Entity.__reset_id__!
-  args.state.player = args.state.new_entity_strict(:player_one, name: "Ryu")
-  args.state.enemy = args.state.new_entity_strict(:enemy, name: "Bison", other_property: 'extra mean')
-
-  serialized_state = args.gtk.serialize_state args.state
-
-  GTK::Entity.__reset_id__!
-  deserialized_state = args.gtk.deserialize_state serialized_state
-
-  assert.equal! deserialized_state.player.name, "Ryu"
-  assert.equal! deserialized_state.enemy.other_property, "extra mean"
+def calc args
+  args.state.ball.debounce -= 1 and return if args.state.ball.debounce > 0
+  calc_move_ball args
+  calc_collision_with_left_paddle args
+  calc_collision_with_right_paddle args
+  calc_collision_with_walls args
 end
 
-def test_by_reference_state args, assert
-  GTK::Entity.__reset_id__!
-  args.state.a = { name: "Jane Doe" }
-  args.state.b = args.state.a
-  assert.equal! args.state.a.object_id, args.state.b.object_id
-  serialized_state = args.gtk.serialize_state args.state
-
-  GTK::Entity.__reset_id__!
-  deserialized_state = args.gtk.deserialize_state serialized_state
-  assert.equal! deserialized_state.a.object_id, deserialized_state.b.object_id
-end
+begin :calc_methods
+  def calc_move_ball args
+    args.state.ball.x += args.state.ball.dx
+    args.state.ball.y += args.state.ball.dy
+  end
 
-def test_by_reference_state_strict_entities args, assert
-  GTK::Entity.__reset_id__!
-  args.state.a = { name: "Jane Doe" }
-  args.state.strict_entity = args.state.new_entity_strict(:couple) do |e|
-    e.one = args.state.new_entity_strict(:person, name: "Jane")
-    e.two = e.one
+  def calc_collision_with_left_paddle args
+    if solid_left_paddle(args).intersect_rect? solid_ball(args)
+      args.state.ball.dx *= -1
+    elsif args.state.ball.x < 0
+      args.state.right_paddle.score += 1
+      calc_reset_round args
+    end
   end
-  assert.equal! args.state.strict_entity.one, args.state.strict_entity.two
-  serialized_state = args.gtk.serialize_state args.state
 
-  GTK::Entity.__reset_id__!
-  deserialized_state = args.gtk.deserialize_state serialized_state
-  assert.equal! deserialized_state.strict_entity.one, deserialized_state.strict_entity.two
-end
+  def calc_collision_with_right_paddle args
+    if solid_right_paddle(args).intersect_rect? solid_ball(args)
+      args.state.ball.dx *= -1
+    elsif args.state.ball.x > 1280
+      args.state.left_paddle.score += 1
+      calc_reset_round args
+    end
+  end
 
-$tests.start
+  def calc_collision_with_walls args
+    if args.state.ball.y + args.state.ball.size_half > 720
+      args.state.ball.y = 720 - args.state.ball.size_half
+      args.state.ball.dy *= -1
+    elsif args.state.ball.y - args.state.ball.size_half < 0
+      args.state.ball.y = args.state.ball.size_half
+      args.state.ball.dy *= -1
+    end
+  end
 
-

-Advanced Debugging - Unit Tests - state_serialization_experimental_tests.rb
-# ./samples/10_advanced_debugging/03_unit_tests/state_serialization_experimental_tests.rb
-MAX_CODE_GEN_LENGTH = 50
+  def calc_reset_round args
+    args.state.ball.x = 640
+    args.state.ball.y = 360
+    args.state.ball.dx = 5.randomize(:sign)
+    args.state.ball.dy = 5.randomize(:sign)
+    args.state.ball.debounce = 3 * 60
+  end
+end
 
-# NOTE: This is experimental/advanced stuff.
-def needs_partitioning? target
-  target[:value].to_s.length > MAX_CODE_GEN_LENGTH
+def input args
+  input_left_paddle args
+  input_right_paddle args
 end
 
-def partition target
-  return [] unless needs_partitioning? target
-  if target[:value].is_a? GTK::OpenEntity
-    target[:value] = target[:value].hash
+begin :input_methods
+  def input_left_paddle args
+    if args.inputs.controller_one.key_down.down  || args.inputs.keyboard.key_down.s
+      args.state.left_paddle.y -= 40
+    elsif args.inputs.controller_one.key_down.up || args.inputs.keyboard.key_down.w
+      args.state.left_paddle.y += 40
+    end
   end
 
-  results = []
-  idx = 0
-  left, right = target[:value].partition do
-    idx += 1
-    idx.even?
+  def input_right_paddle args
+    if args.inputs.controller_two.key_down.down  || args.inputs.keyboard.key_down.l
+      args.state.right_paddle.y -= 40
+    elsif args.inputs.controller_two.key_down.up || args.inputs.keyboard.key_down.o
+      args.state.right_paddle.y += 40
+    end
   end
-  left, right = Hash[left], Hash[right]
-  left = { value: left }
-  right = { value: right}
-  [left, right]
 end
 
-def add_partition target, path, aggregate, final_result
-  partitions = partition target
-  partitions.each do |part|
-    if needs_partitioning? part
-      if part[:value].keys.length == 1
-        first_key = part[:value].keys[0]
-        new_part = { value: part[:value][first_key] }
-        path.push first_key
-        add_partition new_part, path, aggregate, final_result
-        path.pop
-      else
-        add_partition part, path, aggregate, final_result
-      end
-    else
-      final_result << { value: { __path__: [*path] } }
-      final_result << { value: part[:value] }
-    end
+begin :assets
+  def solid_ball args
+    centered_rect args.state.ball.x, args.state.ball.y, args.state.ball.size, args.state.ball.size
   end
-end
 
-def state_to_string state
-  parts_queue = []
-  final_queue = []
-  add_partition({ value: state.hash },
-                [],
-                parts_queue,
-                final_queue)
-  final_queue.reject {|i| i[:value].keys.length == 0}.map do |i|
-    i[:value].to_s
-  end.join("\n#==================================================#\n")
-end
+  def solid_left_paddle args
+    centered_rect_vertically 0, args.state.left_paddle.y, args.state.paddle.w, args.state.paddle.h
+  end
+
+  def solid_right_paddle args
+    centered_rect_vertically 1280 - args.state.paddle.w, args.state.right_paddle.y, args.state.paddle.w, args.state.paddle.h
+  end
 
-def state_from_string string
-  Kernel.eval("$load_data = {}")
-  lines = string.split("\n#==================================================#\n")
-  lines.each do |l|
-    puts "todo: #{l}"
+  def centered_rect x, y, w, h
+    [x - w / 2, y - h / 2, w, h]
   end
 
-  GTK::OpenEntity.parse_from_hash $load_data
+  def centered_rect_vertically x, y, w, h
+    [x, y - h / 2, w, h]
+  end
 end
 
-def test_save_and_load args, assert
-  args.state.item_1.name = "Jane"
-  string = state_to_string args.state
-  state = state_from_string string
-  assert.equal! args.state.item_1.name, state.item_1.name
-end
+
+Arcade - Snakemoji - main.rb
+# ./samples/99_genre_arcade/snakemoji/app/main.rb
+# coding: utf-8
+################################
+#  So I was working on a snake game while
+#  learning DragonRuby, and at some point I had a thought
+#  what if I use "😀" as a function name, surely it wont work right...?
+#  RIGHT....?
+#  BUT IT DID, IT WORKED
+#  it all went downhill from then
+#  Created by Anton K. (ai Doge)
+#  https://gist.github.com/scorp200
+#############LICENSE############
+#  Feel free to use this anywhere and however you want
+#  You can sell this to EA for $1,000,000 if you want, its completely free.
+#  Just rememeber you are helping this... thing... to spread...
+#  ALSO! I am not liable for any mental, physical or financial damage caused.
+#############LICENSE############
 
-def test_save_and_load_big args, assert
-  size = 1000
-  size.map_with_index do |i|
-    args.state.send("k#{i}=".to_sym, i)
+
+class Array
+  #Helper function
+  def move! vector
+    self.x += vector.x
+    self.y += vector.y
+    return self
   end
 
-  string = state_to_string args.state
-  state = state_from_string string
-  size.map_with_index do |i|
-    assert.equal! args.state.send("k#{i}".to_sym), state.send("k#{i}".to_sym)
-    assert.equal! args.state.send("k#{i}".to_sym), i
-    assert.equal! state.send("k#{i}".to_sym), i
+  #Helper function to draw snake body
+  def draw! 🎮, 📺, color
+    translate 📺.solids, 🎮.⛓, [self.x * 🎮.⚖️ + 🎮.🛶 / 2, self.y * 🎮.⚖️ + 🎮.🛶 / 2, 🎮.⚖️ - 🎮.🛶, 🎮.⚖️ - 🎮.🛶, color]
+  end
+
+  #This is where it all started, I was trying to find  good way to multiply a map by a number, * is already used so is **
+  #I kept trying different combinations of symbols, when suddenly...
+  def 😀 value
+    self.map {|d| d * value}
   end
 end
 
-def test_save_and_load_big_nested args, assert
-  args.state.player_one.friend.nested_hash.k0 = 0
-  args.state.player_one.friend.nested_hash.k1 = 1
-  args.state.player_one.friend.nested_hash.k2 = 2
-  args.state.player_one.friend.nested_hash.k3 = 3
-  args.state.player_one.friend.nested_hash.k4 = 4
-  args.state.player_one.friend.nested_hash.k5 = 5
-  args.state.player_one.friend.nested_hash.k6 = 6
-  args.state.player_one.friend.nested_hash.k7 = 7
-  args.state.player_one.friend.nested_hash.k8 = 8
-  args.state.player_one.friend.nested_hash.k9 = 9
-  string = state_to_string args.state
-  state = state_from_string string
+#Draw stuff with an offset
+def translate output_collection, ⛓, what
+  what.x += ⛓.x
+  what.y += ⛓.y
+  output_collection << what
 end
 
-$gtk.reset 100
-$gtk.log_level = :off
-$gtk.tests.start
+BLUE = [33, 150, 243]
+RED = [244, 67, 54]
+GOLD = [255, 193, 7]
+LAST = 0
 
-

-Http - Retrieve Images - main.rb
-# ./samples/11_http/01_retrieve_images/app/main.rb
 def tick args
-  args.outputs.background_color = [0, 0, 0]
-
-  # Show a warning at the start.
-  args.state.warning_debounce ||= 11 * 60
-  if args.state.warning_debounce > 0
-    args.state.warning_debounce -= 1
-    args.outputs.labels << [640, 600, "This app shows random images from the Internet.", 10, 1, 255, 255, 255]
-    args.outputs.labels << [640, 500, "Quit in the next few seconds if this is a problem.", 10, 1, 255, 255, 255]
-    args.outputs.labels << [640, 350, "#{(args.state.warning_debounce / 60.0).to_i}", 10, 1, 255, 255, 255]
-    return
-  end
+  defaults args.state
+  render args.state, args.outputs
+  input args.state, args.inputs
+  update args.state
+end
 
-  args.state.download_debounce ||= 0   # start immediately, reset to non zero later.
-  args.state.photos ||= []
+def update 🎮
+  #Update every 10 frames
+  if 🎮.tick_count.mod_zero? 10
+    #Add new snake body piece at head's location
+    🎮.🐍 << [*🎮.🤖]
+    #Assign Next Direction to Direction
+    🎮.🚗 = *🎮.🚦
 
-  # Put a little pause between each download.
-  if args.state.download.nil?
-    if args.state.download_debounce > 0
-      args.state.download_debounce -= 1
-    else
-      args.state.download = $gtk.http_get 'https://picsum.photos/200/300.jpg'
+    #Trim the snake a bit if its longer than current size
+    if 🎮.🐍.length > 🎮.🛒
+      🎮.🐍 = 🎮.🐍[-🎮.🛒..-1]
     end
-  end
 
-  if !args.state.download.nil?
-    if args.state.download[:complete]
-      if args.state.download[:http_response_code] == 200
-        fname = "sprites/#{args.state.photos.length}.jpg"
-        $gtk.write_file fname, args.state.download[:response_data]
-        args.state.photos << [ 100 + rand(1080), 500 - rand(480), fname, rand(80) - 40 ]
-      end
-      args.state.download = nil
-      args.state.download_debounce = (rand(3) + 2) * 60
-    end
-  end
+    #Move the head in the Direction
+    🎮.🤖.move! 🎮.🚗
 
-  # draw any downloaded photos...
-  args.state.photos.each { |i|
-    args.outputs.primitives << [i[0], i[1], 200, 300, i[2], i[3]].sprite
-  }
+    #If Head is outside the playing field, or inside snake's body restart game
+    if 🎮.🤖.x < 0 || 🎮.🤖.x >= 🎮.🗺.x || 🎮.🤖.y < 0 || 🎮.🤖.y >= 🎮.🗺.y || 🎮.🚗 != [0, 0] && 🎮.🐍.any? {|s| s == 🎮.🤖}
+      LAST = 🎮.💰
+      🎮.as_hash.clear
+      return
+    end
 
-  # Draw a download progress bar...
-  args.outputs.primitives << [0, 0, 1280, 30, 0, 0, 0, 255].solid
-  if !args.state.download.nil?
-    br = args.state.download[:response_read]
-    total = args.state.download[:response_total]
-    if total != 0
-      pct = br.to_f / total.to_f
-      args.outputs.primitives << [0, 0, 1280 * pct, 30, 0, 0, 255, 255].solid
+    #If head lands on food add size and score
+    if 🎮.🤖 == 🎮.🍎
+      🎮.🛒 += 1
+      🎮.💰 += (🎮.🛒 * 0.8).floor.to_i + 5
+      spawn_🍎 🎮
+      puts 🎮.🍎
     end
   end
-end
-
-
-12 C Extensions - Basics - main.rb
-# ./samples/12_c_extensions/01_basics/app/main.rb
-$gtk.ffi_misc.gtk_dlopen("ext")
-include FFI::CExt
 
-def tick args
-  args.outputs.labels  << [640, 500, "mouse.x = #{args.mouse.x.to_i}", 5, 1]
-  args.outputs.labels  << [640, 460, "square(mouse.x) = #{square(args.mouse.x.to_i)}", 5, 1]
-  args.outputs.labels  << [640, 420, "mouse.y = #{args.mouse.y.to_i}", 5, 1]
-  args.outputs.labels  << [640, 380, "square(mouse.y) = #{square(args.mouse.y.to_i)}", 5, 1]
+  #Every second remove 1 point
+  if 🎮.💰 > 0 && 🎮.tick_count.mod_zero?(60)
+    🎮.💰 -= 1
+  end
 end
 
-
-
-12 C Extensions - Intermediate - main.rb
-# ./samples/12_c_extensions/02_intermediate/app/main.rb
-$gtk.ffi_misc.gtk_dlopen("ext")
-include FFI::RE
-
-def split_words(input)
-  words = []
-  last = IntPointer.new
-  re = re_compile("\\w+")
-  first = re_matchp(re, input, last)
-  while first != -1
-    words << input.slice(first, last.value)
-    input = input.slice(last.value + first, input.length)
-    first = re_matchp(re, input, last)
+def spawn_🍎 🎮
+  #Food
+  🎮.🍎 ||= [*🎮.🤖]
+  #Randomly spawns food inside the playing field, keep doing this if the food keeps landing on the snake's body
+  while 🎮.🐍.any? {|s| s == 🎮.🍎} || 🎮.🍎 == 🎮.🤖 do
+    🎮.🍎 = [rand(🎮.🗺.x), rand(🎮.🗺.y)]
   end
-  words
 end
 
-def tick args
-  args.outputs.labels  << [640, 500, split_words("hello, dragonriders!").join(' '), 5, 1]
-end
+def render 🎮, 📺
+  #Paint the background black
+  📺.solids << [0, 0, 1280, 720, 0, 0, 0, 255]
+  #Draw a border for the playing field
+  translate 📺.borders, 🎮.⛓, [0, 0, 🎮.🗺.x * 🎮.⚖️, 🎮.🗺.y * 🎮.⚖️, 255, 255, 255]
 
-
-12 C Extensions - Native Pixel Arrays - main.rb
-# ./samples/12_c_extensions/03_native_pixel_arrays/app/main.rb
-$gtk.ffi_misc.gtk_dlopen("ext")
-include FFI::CExt
+  #Draw the snake's body
+  🎮.🐍.map do |🐍| 🐍.draw! 🎮, 📺, BLUE end
+  #Draw the head
+  🎮.🤖.draw! 🎮, 📺, BLUE
+  #Draw the food
+  🎮.🍎.draw! 🎮, 📺, RED
 
-def tick args
-  args.state.rotation ||= 0
+  #Draw current score
+  translate 📺.labels, 🎮.⛓, [5, 715, "Score: #{🎮.💰}", GOLD]
+  #Draw your last score, if any
+  translate 📺.labels, 🎮.⛓, [[*🎮.🤖.😀(🎮.⚖️)].move!([0, 🎮.⚖️ * 2]), "Your Last score is #{LAST}", 0, 1, GOLD] unless LAST == 0 || 🎮.🚗 != [0, 0]
+  #Draw starting message, only if Direction is 0
+  translate 📺.labels, 🎮.⛓, [🎮.🤖.😀(🎮.⚖️), "Press any Arrow key to start", 0, 1, GOLD] unless 🎮.🚗 != [0, 0]
+end
 
-  update_scanner_texture   # this calls into a C extension!
+def input 🎮, 🕹
+  #Left and Right keyboard input, only change if X direction is 0
+  if 🕹.keyboard.key_held.left && 🎮.🚗.x == 0
+    🎮.🚦 = [-1, 0]
+  elsif 🕹.keyboard.key_held.right && 🎮.🚗.x == 0
+    🎮.🚦 = [1, 0]
+  end
 
-  # New/changed pixel arrays get uploaded to the GPU before we render
-  #  anything. At that point, they can be scaled, rotated, and otherwise
-  #  used like any other sprite.
-  w = 100
-  h = 100
-  x = (1280 - w) / 2
-  y = (720 - h) / 2
-  args.outputs.background_color = [64, 0, 128]
-  args.outputs.primitives << [x, y, w, h, :scanner, args.state.rotation].sprite
-  args.state.rotation += 1
+  #Up and Down keyboard input, only change if Y direction is 0
+  if 🕹.keyboard.key_held.up && 🎮.🚗.y == 0
+    🎮.🚦 = [0, 1]
+  elsif 🕹.keyboard.key_held.down && 🎮.🚗.y == 0
+    🎮.🚦 = [0, -1]
+  end
+end
 
-  args.outputs.primitives << args.gtk.current_framerate_primitives
+def defaults 🎮
+  #Playing field size
+  🎮.🗺 ||= [20, 20]
+  #Scale for drawing, screen height / Field height
+  🎮.⚖️ ||= 720 / 🎮.🗺.y
+  #Offset, offset all rendering to the center of the screen
+  🎮.⛓ ||= [(1280 - 720).fdiv(2), 0]
+  #Padding, make the snake body slightly smaller than the scale
+  🎮.🛶 ||= (🎮.⚖️ * 0.2).to_i
+  #Snake Size
+  🎮.🛒 ||= 3
+  #Snake head, the only part we are actually controlling
+  🎮.🤖 ||= [🎮.🗺.x / 2, 🎮.🗺.y / 2]
+  #Snake body map, follows the head
+  🎮.🐍 ||= []
+  #Direction the head moves to
+  🎮.🚗 ||= [0, 0]
+  #Next_Direction, during input check only change this variable and then when game updates asign this to Direction
+  🎮.🚦 ||= [*🎮.🚗]
+  #Your score
+  🎮.💰 ||= 0
+  #Spawns Food randomly
+  spawn_🍎(🎮) unless 🎮.🍎?
 end
 
+
+Arcade - Solar System - main.rb
+# ./samples/99_genre_arcade/solar_system/app/main.rb
+# Focused tutorial video: https://s3.amazonaws.com/s3.dragonruby.org/dragonruby-nddnug-workshop.mp4
+# Workshop/Presentation which provides motivation for creating a game engine: https://www.youtube.com/watch?v=S3CFce1arC8
 
-

-3d - 3d Cube - main.rb
-# ./samples/99_genre_3d/3d_cube/app/main.rb
-STARTX             = 0.0
-STARTY             = 0.0
-ENDY               = 20.0
-ENDX               = 20.0
-SPINPOINT          = 10
-SPINDURATION       = 400
-POINTSIZE          = 8
-BOXDEPTH           = 40
-YAW                = 1
-DISTANCE           = 10
-
-def tick args
+def defaults args
   args.outputs.background_color = [0, 0, 0]
-  a = Math.sin(args.state.tick_count / SPINDURATION) * Math.tan(args.state.tick_count / SPINDURATION)
-  s = Math.sin(a)
-  c = Math.cos(a)
-  x = STARTX
-  y = STARTY
-  offset_x = (1280 - (ENDX - STARTX)) / 2
-  offset_y =  (360 - (ENDY - STARTY)) / 2
+  args.state.x ||= 640
+  args.state.y ||= 360
+  args.state.stars ||= 100.map do
+    [1280 * rand, 720 * rand, rand.fdiv(10), 255 * rand, 255 * rand, 255 * rand]
+  end
 
-  srand(1)
-  while y < ENDY do
-    while x < ENDX do
-      if (y == STARTY ||
-          y == (ENDY / 0.5) * 2 ||
-          y == (ENDY / 0.5) * 2 + 0.5 ||
-          y == ENDY - 0.5 ||
-          x == STARTX ||
-          x == ENDX - 0.5)
-        z = rand(BOXDEPTH)
-        z *= Math.sin(a / 2)
-        x -= SPINPOINT
-        u = (x * c) - (z * s)
-        v = (x * s) + (z * c)
-        k = DISTANCE.fdiv(100) + (v / 500 * YAW)
-        u = u / k
-        v = y / k
-        w = POINTSIZE / 10 / k
-        args.outputs.sprites << { x: offset_x + u - w, y: offset_y + v - w, w: w, h: w, path: 'sprites/square-blue.png'}
-        x += SPINPOINT
-      end
-      x += 0.5
+  args.state.sun ||= args.state.new_entity(:sun) do |s|
+    s.s = 100
+    s.path = 'sprites/sun.png'
+  end
+
+  args.state.planets = [
+    [:mercury,   65,  5,          88],
+    [:venus,    100, 10,         225],
+    [:earth,    120, 10,         365],
+    [:mars,     140,  8,         687],
+    [:jupiter,  280, 30, 365 *  11.8],
+    [:saturn,   350, 20, 365 *  29.5],
+    [:uranus,   400, 15, 365 *    84],
+    [:neptune,  440, 15, 365 * 164.8],
+    [:pluto,    480,  5, 365 * 247.8],
+  ].map do |name, distance, size, year_in_days|
+    args.state.new_entity(name) do |p|
+      p.path = "sprites/#{name}.png"
+      p.distance = distance * 0.7
+      p.s = size * 0.7
+      p.year_in_days = year_in_days
     end
-    y += 0.5
-    x = STARTX
   end
-end
 
-$gtk.reset
+  args.state.ship ||= args.state.new_entity(:ship) do |s|
+    s.x = 1280 * rand
+    s.y = 720 * rand
+    s.angle = 0
+  end
+end
 
-
-Arcade - Dueling Starships - main.rb
-# ./samples/99_genre_arcade/dueling_starships/app/main.rb
-class DuelingSpaceships
-  attr_accessor :state, :inputs, :outputs, :grid
+def to_sprite args, entity
+  x = 0
+  y = 0
 
-  def tick
-    defaults
-    render
-    calc
-    input
+  if entity.year_in_days
+    day = args.state.tick_count
+    day_in_year = day % entity.year_in_days
+    entity.random_start_day ||= day_in_year * rand
+    percentage_of_year = day_in_year.fdiv(entity.year_in_days)
+    angle = 365 * percentage_of_year
+    x = angle.vector_x(entity.distance)
+    y = angle.vector_y(entity.distance)
   end
 
-  def defaults
-    outputs.background_color = [0, 0, 0]
-    state.ship_blue       ||= new_blue_ship
-    state.ship_red        ||= new_red_ship
-    state.flames          ||= []
-    state.bullets         ||= []
-    state.ship_blue_score ||= 0
-    state.ship_red_score  ||= 0
-    state.stars           ||= 100.map do
-      [rand.add(2).to_square(grid.w_half.randomize(:sign, :ratio),
-                             grid.h_half.randomize(:sign, :ratio)),
-       128 + 128.randomize(:ratio), 255, 255]
-    end
-  end
+  [640 + x - entity.s.half, 360 + y - entity.s.half, entity.s, entity.s, entity.path]
+end
 
-  def default_ship x, y, angle, sprite_path, bullet_sprite_path, color
-    state.new_entity(:ship,
-                    { x: x,
-                      y: y,
-                      dy: 0,
-                      dx: 0,
-                      damage: 0,
-                      dead: false,
-                      angle: angle,
-                      max_alpha: 255,
-                      sprite_path: sprite_path,
-                      bullet_sprite_path: bullet_sprite_path,
-                      color: color })
+def render args
+  args.outputs.solids << [0, 0, 1280, 720]
+
+  args.outputs.sprites << args.state.stars.map do |x, y, _, r, g, b|
+    [x, y, 10, 10, 'sprites/star.png', 0, 100, r, g, b]
   end
 
-  def new_red_ship
-    default_ship(400, 250.randomize(:sign, :ratio),
-                 180, 'sprites/ship_red.png', 'sprites/red_bullet.png',
-                 [255, 90, 90])
+  args.outputs.sprites << to_sprite(args, args.state.sun)
+  args.outputs.sprites << args.state.planets.map { |p| to_sprite args, p }
+  args.outputs.sprites << [args.state.ship.x, args.state.ship.y, 20, 20, 'sprites/ship.png', args.state.ship.angle]
+end
+
+def calc args
+  args.state.stars = args.state.stars.map do |x, y, speed, r, g, b|
+    x += speed
+    y += speed
+    x = 0 if x > 1280
+    y = 0 if y > 720
+    [x, y, speed, r, g, b]
   end
 
-  def new_blue_ship
-    default_ship(-400, 250.randomize(:sign, :ratio),
-                 0, 'sprites/ship_blue.png', 'sprites/blue_bullet.png',
-                 [110, 140, 255])
+  if args.state.tick_count == 0
+    args.outputs.sounds << 'sounds/bg.ogg'
   end
+end
 
-  def render
-    render_instructions
-    render_score
-    render_universe
-    render_flames
-    render_ships
-    render_bullets
+def process_inputs args
+  if args.inputs.keyboard.left || args.inputs.controller_one.key_held.left
+    args.state.ship.angle += 1
+  elsif args.inputs.keyboard.right || args.inputs.controller_one.key_held.right
+    args.state.ship.angle -= 1
   end
 
-  def render_ships
-    update_ship_outputs(state.ship_blue)
-    update_ship_outputs(state.ship_red)
-    outputs.sprites << [state.ship_blue.sprite, state.ship_red.sprite]
-    outputs.labels  << [state.ship_blue.label, state.ship_red.label]
+  if args.inputs.keyboard.up || args.inputs.controller_one.key_held.a
+    args.state.ship.x += args.state.ship.angle.x_vector
+    args.state.ship.y += args.state.ship.angle.y_vector
   end
+end
 
-  def render_instructions
-    return if state.ship_blue.dx  > 0  || state.ship_blue.dy > 0  ||
-              state.ship_red.dx   > 0  || state.ship_red.dy  > 0  ||
-              state.flames.length > 0
+def tick args
+  defaults args
+  render args
+  calc args
+  process_inputs args
+end
 
-    outputs.labels << [grid.left.shift_right(30),
-                       grid.bottom.shift_up(30),
-                       "Two gamepads needed to play. R1 to accelerate. Left and right on D-PAD to turn ship. Hold A to shoot. Press B to drop mines.",
-                       0, 0, 255, 255, 255]
-  end
+def r
+  $gtk.reset
+end
 
-  def calc
-    calc_thrusts
-    calc_ships
-    calc_bullets
-    calc_winner
-  end
+
+Arcade - Sound Golf - main.rb
+# ./samples/99_genre_arcade/sound_golf/app/main.rb
+=begin
 
-  def input
-    input_accelerate
-    input_turn
-    input_bullets_and_mines
-  end
+ APIs Listing that haven't been encountered in previous sample apps:
 
-  def render_score
-    outputs.labels << [grid.left.shift_right(80),
-                       grid.top.shift_down(40),
-                       state.ship_blue_score, 30, 1, state.ship_blue.color]
+ - sample: Chooses random element from array.
+   In this sample app, the target note is set by taking a sample from the collection
+   of available notes.
 
-    outputs.labels << [grid.right.shift_left(80),
-                       grid.top.shift_down(40),
-                       state.ship_red_score,  30, 1, state.ship_red.color]
-  end
+ Reminders:
+ - args.grid.(left|right|top|bottom): Pixel value for the boundaries of the virtual
+   720 p screen (Dragon Ruby Game Toolkits's virtual resolution is always 1280x720).
 
-  def render_universe
-    return if outputs.static_solids.any?
-    outputs.static_solids << grid.rect
-    outputs.static_solids << state.stars
-  end
+ - args.state.new_entity: Used when we want to create a new object, like a sprite or button.
+   For example, if we want to create a new button, we would declare it as a new entity and
+   then define its properties.
 
-  def apply_round_finished_alpha entity
-    return entity unless state.round_finished_debounce
-    entity.a *= state.round_finished_debounce.percentage_of(2.seconds)
-    return entity
-  end
+ - String interpolation: Uses #{} syntax; everything between the #{ and the } is evaluated
+   as Ruby code, and the placeholder is replaced with its corresponding value or result.
 
-  def update_ship_outputs ship, sprite_size = 66
-    ship.sprite =
-      apply_round_finished_alpha [sprite_size.to_square(ship.x, ship.y),
-                                  ship.sprite_path,
-                                  ship.angle,
-                                  ship.dead ? 0 : 255 * ship.created_at.ease(2.seconds)].sprite
-    ship.label =
-      apply_round_finished_alpha [ship.x,
-                                  ship.y + 100,
-                                  "." * 5.minus(ship.damage).greater(0), 20, 1, ship.color, 255].label
-  end
+ - args.outputs.labels: An array. The values generate a label.
+   The parameters are [X, Y, TEXT, SIZE, ALIGNMENT, RED, GREEN, BLUE, ALPHA, FONT STYLE]
+   For more information about labels, go to mygame/documentation/02-labels.md.
 
-  def render_flames sprite_size = 6
-    outputs.sprites << state.flames.map do |p|
-      apply_round_finished_alpha [sprite_size.to_square(p.x, p.y),
-                                  'sprites/flame.png', 0,
-                                  p.max_alpha * p.created_at.ease(p.lifetime, :flip)].sprite
-    end
-  end
+ - find_all: Finds all elements from a collection that meet a certain requirements (and excludes the ones that don't).
 
-  def render_bullets sprite_size = 10
-    outputs.sprites << state.bullets.map do |b|
-      apply_round_finished_alpha [b.sprite_size.to_square(b.x, b.y),
-                                  b.owner.bullet_sprite_path,
-                                  0, b.max_alpha].sprite
-    end
-  end
+ - first: Returns the first element of an array.
 
-  def wrap_location! location
-    location.x = grid.left    if location.x > grid.right
-    location.x = grid.right   if location.x < grid.left
-    location.y = grid.top     if location.y < grid.bottom
-    location.y = grid.bottom  if location.y > grid.top
-    location
-  end
+ - inside_rect: Returns true or false depending on if the point is inside the rect.
 
-  def calc_thrusts
-    state.flames =
-      state.flames
-        .reject(&:old?)
-        .map do |p|
-          p.speed *= 0.9
-          p.y += p.angle.vector_y(p.speed)
-          p.x += p.angle.vector_x(p.speed)
-          wrap_location! p
-      end
-  end
+ - to_sym: Returns symbol corresponding to string. Will create a symbol if it does
+   not already exist.
 
-  def all_ships
-    [state.ship_blue, state.ship_red]
-  end
+=end
 
-  def alive_ships
-    all_ships.reject { |s| s.dead }
-  end
+# This sample app allows users to test their musical skills by matching the piano sound that plays in each
+# level to the correct note.
 
-  def calc_bullet bullet
-    bullet.y += bullet.angle.vector_y(bullet.speed)
-    bullet.x += bullet.angle.vector_x(bullet.speed)
-    wrap_location! bullet
-    explode_bullet! bullet if bullet.old?
-    return if bullet.exploded
-    return if state.round_finished
-    alive_ships.each do |s|
-      if s != bullet.owner &&
-         s.sprite.intersect_rect?(bullet.sprite_size.to_square(bullet.x, bullet.y))
-        explode_bullet! bullet, 10, 5, 30
-        s.damage += 1
-      end
-    end
-  end
+# Runs all the methods necessary for the game to function properly.
+def tick args
+  defaults args
+  render args
+  calc args
+  input_mouse args
+  tick_instructions args, "Sample app shows how to play sounds. args.outputs.sounds << \"path_to_wav.wav\""
+end
 
-  def calc_bullets
-    state.bullets.each    { |b| calc_bullet b }
-    state.bullets.reject! { |b| b.exploded }
-  end
+# Sets default values and creates empty collections
+# Initialization happens in the first frame only
+def defaults args
+  args.state.notes ||= []
+  args.state.click_feedbacks ||= []
+  args.state.current_level ||= 1
+  args.state.times_wrong ||= 0 # when game starts, user hasn't guessed wrong yet
+end
 
-  def create_explosion! type, entity, flame_count, max_speed, lifetime, max_alpha = 255
-    flame_count.times do
-      state.flames << state.new_entity(type,
-                                     { angle: 360.randomize(:ratio),
-                                       speed: max_speed.randomize(:ratio),
-                                       lifetime: lifetime,
-                                       x: entity.x,
-                                       y: entity.y,
-                                       max_alpha: max_alpha })
-    end
-  end
+# Uses a label to display current level, and shows the score
+# Creates a button to play the sample note, and displays the available notes that could be a potential match
+def render args
 
-  def explode_bullet! bullet, flame_override = 5, max_speed = 5, lifetime = 10
-    bullet.exploded = true
-    create_explosion! :bullet_explosion,
-                      bullet,
-                      flame_override,
-                      max_speed,
-                      lifetime,
-                      bullet.max_alpha
-  end
+  # grid.w_half positions the label in the horizontal center of the screen.
+  args.outputs.labels << [args.grid.w_half, args.grid.top.shift_down(40), "Hole #{args.state.current_level} of 9", 0, 1, 0, 0, 0]
 
-  def calc_ship ship
-    ship.x += ship.dx
-    ship.y += ship.dy
-    wrap_location! ship
-  end
+  render_score args # shows score on screen
 
-  def calc_ships
-    all_ships.each { |s| calc_ship s }
-    return if all_ships.any? { |s| s.dead }
-    return if state.round_finished
-    return unless state.ship_blue.sprite.intersect_rect?(state.ship_red.sprite)
-    state.ship_blue.damage = 5
-    state.ship_red.damage  = 5
-  end
+  args.state.play_again_button ||= { x: 560, y: args.grid.h * 3 / 4 - 40, w: 160, h: 60, label: 'again' } # array definition, text/title
+  args.state.play_note_button ||= { x: 560, y: args.grid.h * 3 / 4 - 40, w: 160, h: 60, label: 'play' }
 
-  def create_thruster_flames! ship
-    state.flames << state.new_entity(:ship_thruster,
-                                   { angle: ship.angle + 180 + 60.randomize(:sign, :ratio),
-                                     speed: 5.randomize(:ratio),
-                                     max_alpha: 255 * ship.created_at_elapsed.percentage_of(2.seconds),
-                                     lifetime: 30,
-                                     x: ship.x - ship.angle.vector_x(40) + 5.randomize(:sign, :ratio),
-                                     y: ship.y - ship.angle.vector_y(40) + 5.randomize(:sign, :ratio) })
+  if args.state.game_over # if game is over, a "play again" button is shown
+    # Calculations ensure that Play Again label is displayed in center of border
+    # Remove calculations from y parameters and see what happens to border and label placement
+    args.outputs.labels <<  [args.grid.w_half, args.grid.h * 3 / 4, "Play Again", 0, 1, 0, 0, 0] # outputs label
+    args.outputs.borders << args.state.play_again_button # outputs border
+  else # otherwise, if game is not over
+    # Calculations ensure that label appears in center of border
+    args.outputs.labels <<  [args.grid.w_half, args.grid.h * 3 / 4, "Play Note ##{args.state.current_level}", 0, 1, 0, 0, 0] # outputs label
+    args.outputs.borders << args.state.play_note_button # outputs border
   end
 
-  def input_accelerate_ship should_move_ship, ship
-    return if ship.dead
+  return if args.state.game_over # return if game is over
 
-    should_move_ship &&= (ship.dx + ship.dy).abs < 5
+  args.outputs.labels <<   [args.grid.w_half, 400, "I think the note is a(n)...",  0, 1, 0, 0, 0] # outputs label
 
-    if should_move_ship
-      create_thruster_flames! ship
-      ship.dx += ship.angle.vector_x 0.050
-      ship.dy += ship.angle.vector_y 0.050
-    else
-      ship.dx *= 0.99
-      ship.dy *= 0.99
-    end
+  # Shows all of the available notes that can be potential matches.
+  available_notes.each_with_index do |note, i|
+    args.state.notes[i] ||= piano_button(args, note, i + 1) # calls piano_button method on each note (creates label and border)
+    args.outputs.labels <<   args.state.notes[i].label # outputs note on screen with a label and a border
+    args.outputs.borders <<  args.state.notes[i].border
   end
 
-  def input_accelerate
-    input_accelerate_ship inputs.controller_one.key_held.r1 || inputs.keyboard.up, state.ship_blue
-    input_accelerate_ship inputs.controller_two.key_held.r1, state.ship_red
-  end
+  # Shows whether or not the user is correct by filling the screen with either red or green
+  args.outputs.solids << args.state.click_feedbacks.map { |c| c.solid }
+end
 
-  def input_turn_ship direction, ship
-    ship.angle -= 3 * direction
+# Shows the score (number of times the user guesses wrong) onto the screen using labels.
+def render_score args
+  if args.state.times_wrong == 0 # if the user has guessed wrong zero times, the score is par
+    args.outputs.labels << [args.grid.w_half, args.grid.top.shift_down(80), "Score: PAR", 0, 1, 0, 0, 0]
+  else # otherwise, number of times the user has guessed wrong is shown
+    args.outputs.labels << [args.grid.w_half, args.grid.top.shift_down(80), "Score: +#{args.state.times_wrong}", 0, 1, 0, 0, 0] # shows score using string interpolation
   end
+end
 
-  def input_turn
-    input_turn_ship inputs.controller_one.left_right + inputs.keyboard.left_right, state.ship_blue
-    input_turn_ship inputs.controller_two.left_right, state.ship_red
-  end
+# Sets the target note for the level and performs calculations on click_feedbacks.
+def calc args
+  args.state.target_note ||= available_notes.sample # chooses a note from available_notes collection as target note
+  args.state.click_feedbacks.each    { |c| c.solid[-1] -= 5 } # remove this line and solid color will remain on screen indefinitely
+  # comment this line out and the solid color will keep flashing on screen instead of being removed from click_feedbacks collection
+  args.state.click_feedbacks.reject! { |c| c.solid[-1] <= 0 }
+end
 
-  def input_bullet create_bullet, ship
-    return unless create_bullet
-    return if ship.dead
+# Uses input from the user to play the target note, as well as the other notes that could be a potential match.
+def input_mouse args
+  return unless args.inputs.mouse.click # return unless the mouse is clicked
 
-    state.bullets << state.new_entity(:ship_bullet,
-                                    { owner: ship,
-                                      angle: ship.angle,
-                                      max_alpha: 255 * ship.created_at_elapsed.percentage_of(2.seconds),
-                                      speed: 5 + ship.dx.mult(ship.angle.vector_x) + ship.dy.mult(ship.angle.vector_y),
-                                      lifetime: 120,
-                                      sprite_size: 10,
-                                      x: ship.x + ship.angle.vector_x * 32,
-                                      y: ship.y + ship.angle.vector_y * 32 })
-  end
+  # finds button that was clicked by user
+  button_clicked = args.outputs.borders.find_all do |b| # go through borders collection to find all borders that meet requirements
+    args.inputs.mouse.click.point.inside_rect? b # find button border that mouse was clicked inside of
+  end.find_all { |b| b.is_a? Hash }.first # reject, return first element
 
-  def input_mine create_mine, ship
-    return unless create_mine
-    return if ship.dead
+  return unless button_clicked # return unless button_clicked as a value (a button was clicked)
 
-    state.bullets << state.new_entity(:ship_bullet,
-                                    { owner: ship,
-                                      angle: 360.randomize(:sign, :ratio),
-                                      max_alpha: 255 * ship.created_at_elapsed.percentage_of(2.seconds),
-                                      speed: 0.02,
-                                      sprite_size: 10,
-                                      lifetime: 600,
-                                      x: ship.x + ship.angle.vector_x * -50,
-                                      y: ship.y + ship.angle.vector_y * -50 })
-  end
+  queue_click_feedback args, # calls queue_click_feedback method on the button that was clicked
+                       button_clicked.x,
+                       button_clicked.y,
+                       button_clicked.w,
+                       button_clicked.h,
+                       150, 100, 200 # sets color of button to shade of purple
 
-  def input_bullets_and_mines
-    return if state.bullets.length > 100
+  if button_clicked[:label] == 'play' # if "play note" button is pressed
+    args.outputs.sounds << "sounds/#{args.state.target_note}.wav" # sound of target note is output
+  elsif button_clicked[:label] == 'again' # if "play game again" button is pressed
+    args.state.target_note = nil # no target note
+    args.state.current_level = 1 # starts at level 1 again
+    args.state.times_wrong = 0 # starts off with 0 wrong guesses
+    args.state.game_over = false # the game is not over (because it has just been restarted)
+  else # otherwise if neither of those buttons were pressed
+    args.outputs.sounds << "sounds/#{button_clicked[:label]}.wav" # sound of clicked note is played
+    if button_clicked[:label] == args.state.target_note # if clicked note is target note
+      args.state.target_note = nil # target note is emptied
 
-    [
-      [inputs.controller_one.key_held.a || inputs.keyboard.key_held.space,
-       inputs.controller_one.key_down.b || inputs.keyboard.key_down.down,
-       state.ship_blue],
-      [inputs.controller_two.key_held.a, inputs.controller_two.key_down.b, state.ship_red]
-    ].each do |a_held, b_down, ship|
-      input_bullet(a_held && state.tick_count.mod_zero?(10).or(a_held == 0), ship)
-      input_mine(b_down, ship)
-    end
-  end
+      if args.state.current_level < 9 # if game hasn't reached level 9
+        args.state.current_level += 1 # game goes to next level
+      else # otherwise, if game has reached level 9
+        args.state.game_over = true # the game is over
+      end
 
-  def calc_kill_ships
-    alive_ships.find_all { |s| s.damage >= 5 }.each do |s|
-      s.dead = true
-      create_explosion! :ship_explosion, s, 20, 20, 30, s.max_alpha
+      queue_click_feedback args, 0, 0, args.grid.w, args.grid.h, 100, 200, 100 # green shown if user guesses correctly
+    else # otherwise, if clicked note is not target note
+      args.state.times_wrong += 1 # increments times user guessed wrong
+      queue_click_feedback args, 0, 0, args.grid.w, args.grid.h, 200, 100, 100 # red shown is user guesses wrong
     end
   end
+end
 
-  def calc_score
-    return if state.round_finished
-    return if alive_ships.length > 1
+# Creates a collection of all of the available notes as symbols
+def available_notes
+  [:C3, :D3, :E3, :F3, :G3, :A3, :B3, :C4]
+end
 
-    if alive_ships.first == state.ship_red
-      state.ship_red_score += 1
-    elsif alive_ships.first == state.ship_blue
-      state.ship_blue_score += 1
-    end
+# Creates buttons for each note, and sets a label (the note's name) and border for each note's button.
+def piano_button args, note, position
+  args.state.new_entity(:button) do |b| # declares button as new entity
+    b.label  =  [460 + 40.mult(position), args.grid.h * 0.4, "#{note}", 0, 1, 0, 0, 0] # label definition
+    b.border =  { x: 460 + 40.mult(position) - 20, y: args.grid.h * 0.4 - 32, w: 40, h: 40, label: note } # border definition, text/title; 20 subtracted so label is in center of border
+  end
+end
 
-    state.round_finished = true
+# Color of click feedback changes depending on what button was clicked, and whether the guess is right or wrong
+# If a button is clicked, the inside of button is purple (see input_mouse method)
+# If correct note is clicked, screen turns green
+# If incorrect note is clicked, screen turns red (again, see input_mouse method)
+def queue_click_feedback args, x, y, w, h, *color
+  args.state.click_feedbacks << args.state.new_entity(:click_feedback) do |c| # declares feedback as new entity
+    c.solid =  [x, y, w, h, *color, 255] # sets color
+  end
+end
+
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
   end
 
-  def calc_reset_ships
-    return unless state.round_finished
-    state.round_finished_debounce ||= 2.seconds
-    state.round_finished_debounce -= 1
-    return if state.round_finished_debounce > 0
-    start_new_round!
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+end
+
+
+Arcade - Twinstick - main.rb
+# ./samples/99_genre_arcade/twinstick/app/main.rb
+def tick args
+  args.state.player         ||= {x: 600, y: 320, w: 80, h: 80, path: 'sprites/circle-white.png', vx: 0, vy: 0, health: 10, cooldown: 0, score: 0}
+  args.state.enemies        ||= []
+  args.state.player_bullets ||= []
+  args.state.tick_count     ||= -1
+  args.state.tick_count     += 1
+  spawn_enemies args
+  kill_enemies args
+  move_enemies args
+  move_bullets args
+  move_player args
+  fire_player args
+  args.state.player[:r] = args.state.player[:g] = args.state.player[:b] = (args.state.player[:health] * 25.5).clamp(0, 255)
+  label_color           = args.state.player[:health] <= 5 ? 255 : 0
+  args.outputs.labels << [
+      {
+          x: args.state.player.x + 40, y: args.state.player.y + 60, alignment_enum: 1, text: "#{args.state.player[:health]} HP",
+          r: label_color, g: label_color, b: label_color
+      }, {
+          x: args.state.player.x + 40, y: args.state.player.y + 40, alignment_enum: 1, text: "#{args.state.player[:score]} PTS",
+          r: label_color, g: label_color, b: label_color, size_enum: 2 - args.state.player[:score].to_s.length,
+      }
+  ]
+  args.outputs.sprites << [args.state.player, args.state.enemies, args.state.player_bullets]
+  args.state.clear! if args.state.player[:health] < 0 # Reset the game if the player's health drops below zero
+end
+
+def spawn_enemies args
+  # Spawn enemies more frequently as the player's score increases.
+  if rand < (100+args.state.player[:score])/(10000 + args.state.player[:score]) || args.state.tick_count.zero?
+    theta = rand * Math::PI * 2
+    args.state.enemies << {
+        x: 600 + Math.cos(theta) * 800, y: 320 + Math.sin(theta) * 800, w: 80, h: 80, path: 'sprites/circle-white.png',
+        r: (256 * rand).floor, g: (256 * rand).floor, b: (256 * rand).floor
+    }
   end
+end
 
-  def start_new_round!
-    state.ship_blue = new_blue_ship
-    state.ship_red  = new_red_ship
-    state.round_finished = false
-    state.round_finished_debounce = nil
-    state.flames.clear
-    state.bullets.clear
+def kill_enemies args
+  args.state.enemies.reject! do |enemy|
+    # Check if enemy and player are within 80 pixels of each other (i.e. overlapping)
+    if 6400 > (enemy.x - args.state.player.x) ** 2 + (enemy.y - args.state.player.y) ** 2
+      # Enemy is touching player. Kill enemy, and reduce player HP by 1.
+      args.state.player[:health] -= 1
+    else
+      args.state.player_bullets.any? do |bullet|
+        # Check if enemy and bullet are within 50 pixels of each other (i.e. overlapping)
+        if 2500 > (enemy.x - bullet.x + 30) ** 2 + (enemy.y - bullet.y + 30) ** 2
+          # Increase player health by one for each enemy killed by a bullet after the first enemy, up to a maximum of 10 HP
+          args.state.player[:health] += 1 if args.state.player[:health] < 10 && bullet[:kills] > 0
+          # Keep track of how many enemies have been killed by this particular bullet
+          bullet[:kills]             += 1
+          # Earn more points by killing multiple enemies with one shot.
+          args.state.player[:score]  += bullet[:kills]
+        end
+      end
+    end
   end
+end
 
-  def calc_winner
-    calc_kill_ships
-    calc_score
-    calc_reset_ships
+def move_enemies args
+  args.state.enemies.each do |enemy|
+    # Get the angle from the enemy to the player
+    theta   = Math.atan2(enemy.y - args.state.player.y, enemy.x - args.state.player.x)
+    # Convert the angle to a vector pointing at the player
+    dx, dy  = theta.to_degrees.vector 5
+    # Move the enemy towards thr player
+    enemy.x -= dx
+    enemy.y -= dy
   end
 end
 
-$dueling_spaceship = DuelingSpaceships.new
+def move_bullets args
+  args.state.player_bullets.each do |bullet|
+    # Move the bullets according to the bullet's velocity
+    bullet.x += bullet[:vx]
+    bullet.y += bullet[:vy]
+  end
+  args.state.player_bullets.reject! do |bullet|
+    # Despawn bullets that are outside the screen area
+    bullet.x < -20 || bullet.y < -20 || bullet.x > 1300 || bullet.y > 740
+  end
+end
+
+def move_player args
+  # Get the currently held direction.
+  dx, dy                 = move_directional_vector args
+  # Take the weighted average of the old velocities and the desired velocities.
+  # Since move_directional_vector returns values between -1 and 1,
+  #   and we want to limit the speed to 7.5, we multiply dx and dy by 7.5*0.1 to get 0.75
+  args.state.player[:vx] = args.state.player[:vx] * 0.9 + dx * 0.75
+  args.state.player[:vy] = args.state.player[:vy] * 0.9 + dy * 0.75
+  # Move the player
+  args.state.player.x    += args.state.player[:vx]
+  args.state.player.y    += args.state.player[:vy]
+  # If the player is about to go out of bounds, put them back in bounds.
+  args.state.player.x    = args.state.player.x.clamp(0, 1201)
+  args.state.player.y    = args.state.player.y.clamp(0, 640)
+end
+
+
+def fire_player args
+  # Reduce the firing cooldown each tick
+  args.state.player[:cooldown] -= 1
+  # If the player is allowed to fire
+  if args.state.player[:cooldown] <= 0
+    dx, dy = shoot_directional_vector args # Get the bullet velocity
+    return if dx == 0 && dy == 0 # If the velocity is zero, the player doesn't want to fire. Therefore, we just return early.
+    # Add a new bullet to the list of player bullets.
+    args.state.player_bullets << {
+        x:     args.state.player.x + 30 + 40 * dx,
+        y:     args.state.player.y + 30 + 40 * dy,
+        w:     20, h: 20,
+        path:  'sprites/circle-white.png',
+        r:     0, g: 0, b: 0,
+        vx:    10 * dx + args.state.player[:vx] / 7.5, vy: 10 * dy + args.state.player[:vy] / 7.5, # Factor in a bit of the player's velocity
+        kills: 0
+    }
+    args.state.player[:cooldown] = 30 # Reset the cooldown
+  end
+end
+
+# Custom function for getting a directional vector just for movement using WASD
+def move_directional_vector args
+  dx = 0
+  dx += 1 if args.inputs.keyboard.d
+  dx -= 1 if args.inputs.keyboard.a
+  dy = 0
+  dy += 1 if args.inputs.keyboard.w
+  dy -= 1 if args.inputs.keyboard.s
+  if dx != 0 && dy != 0
+    dx *= 0.7071
+    dy *= 0.7071
+  end
+  [dx, dy]
+end
+
+# Custom function for getting a directional vector just for shooting using the arrow keys
+def shoot_directional_vector args
+  dx = 0
+  dx += 1 if args.inputs.keyboard.key_down.right || args.inputs.keyboard.key_held.right
+  dx -= 1 if args.inputs.keyboard.key_down.left || args.inputs.keyboard.key_held.left
+  dy = 0
+  dy += 1 if args.inputs.keyboard.key_down.up || args.inputs.keyboard.key_held.up
+  dy -= 1 if args.inputs.keyboard.key_down.down || args.inputs.keyboard.key_held.down
+  if dx != 0 && dy != 0
+    dx *= 0.7071
+    dy *= 0.7071
+  end
+  [dx, dy]
+end
+
+Crafting - Craft Game Starting Point - main.rb
+# ./samples/99_genre_crafting/craft_game_starting_point/app/main.rb
+# ==================================================
+# A NOTE TO JAM CRAFT PARTICIPANTS:
+# The comments and code in here are just as small piece of DragonRuby's capabilities.
+# Be sure to check out the rest of the sample apps. Start with README.txt and go from there!
+# ==================================================
 
+# def tick args is the entry point into your game. This function is called at
+# a fixed update time of 60hz (60 fps).
 def tick args
-  args.grid.origin_center!
-  $dueling_spaceship.inputs  = args.inputs
-  $dueling_spaceship.outputs = args.outputs
-  $dueling_spaceship.state    = args.state
-  $dueling_spaceship.grid    = args.grid
-  $dueling_spaceship.tick
-end
+  # The defaults function intitializes the game.
+  defaults args
 
-

-arcade/flappy dragon/credits.txt
-# ./samples/99_genre_arcade/flappy_dragon/CREDITS.txt
-code: Amir Rajan, https://twitter.com/amirrajan
-graphics and audio: Nick Culbertson, https://twitter.com/MobyPixel
+  # After the game is initialized, render it.
+  render args
 
+  # After rendering the player should be able to respond to input.
+  input args
 
-
-arcade/flappy dragon/main.rb
-# ./samples/99_genre_arcade/flappy_dragon/app/main.rb
-class FlappyDragon
-  attr_accessor :grid, :inputs, :state, :outputs
+  # After responding to input, the game performs any additional calculations.
+  calc args
+end
 
-  def tick
-    defaults
-    render
-    calc
-    process_inputs
+def defaults args
+  # hide the mouse cursor for this game, we are going to render our own cursor
+  if args.state.tick_count == 0
+    args.gtk.hide_cursor
   end
 
-  def defaults
-    state.flap_power              = 11
-    state.gravity                 = 0.9
-    state.ceiling                 = 600
-    state.ceiling_flap_power      = 6
-    state.wall_countdown_length   = 100
-    state.wall_gap_size           = 100
-    state.wall_countdown        ||= 0
-    state.hi_score              ||= 0
-    state.score                 ||= 0
-    state.walls                 ||= []
-    state.x                     ||= 50
-    state.y                     ||= 500
-    state.dy                    ||= 0
-    state.scene                 ||= :menu
-    state.scene_at              ||= 0
-    state.difficulty            ||= :normal
-    state.new_difficulty        ||= :normal
-    state.countdown             ||= 4.seconds
-    state.flash_at              ||= 0
-  end
+  args.state.click_ripples ||= []
 
-  def render
-    outputs.sounds << "sounds/flappy-song.ogg" if state.tick_count == 1
-    render_score
-    render_menu
-    render_game
-  end
+  # everything is on a 1280x720 virtual canvas, so you can
+  # hardcode locations
 
-  def render_score
-    outputs.primitives << [10, 710, "HI SCORE: #{state.hi_score}", large_white_typeset].label
-    outputs.primitives << [10, 680, "SCORE: #{state.score}", large_white_typeset].label
-    outputs.primitives << [10, 650, "DIFFICULTY: #{state.difficulty.upcase}", large_white_typeset].label
-  end
+  # define the borders for where the inventory is located
+  # args.state is a data structure that accepts any arbitrary parameters
+  # so you can create an object graph without having to create any classes.
 
-  def render_menu
-    return unless state.scene == :menu
-    render_overlay
+  # Bottom left is 0, 0. Top right is 1280, 720.
+  # The inventory area is at the top of the screen
+  # the number 80 is the size of all the sprites, so that is what is being
+  # used to decide the with and height
+  args.state.sprite_size = 80
 
-    outputs.labels << [640, 700, "Flappy Dragon", 50, 1, 255, 255, 255]
-    outputs.labels << [640, 500, "Instructions: Press Spacebar to flap. Don't die.", 4, 1, 255, 255, 255]
-    outputs.labels << [430, 430, "[Tab]    Change difficulty", 4, 0, 255, 255, 255]
-    outputs.labels << [430, 400, "[Enter]  Start at New Difficulty ", 4, 0, 255, 255, 255]
-    outputs.labels << [430, 370, "[Escape] Cancel/Resume ", 4, 0, 255, 255, 255]
-    outputs.labels << [640, 300, "(mouse, touch, and game controllers work, too!) ", 4, 1, 255, 255, 255]
-    outputs.labels << [640, 200, "Difficulty: #{state.new_difficulty.capitalize}", 4, 1, 255, 255, 255]
+  args.state.inventory_border.w  = args.state.sprite_size * 10
+  args.state.inventory_border.h  = args.state.sprite_size * 3
+  args.state.inventory_border.x  = 10
+  args.state.inventory_border.y  = 710 - args.state.inventory_border.h
 
-    outputs.labels << [10, 100, "Code:   @amirrajan",     255, 255, 255]
-    outputs.labels << [10,  80, "Art:    @mobypixel",     255, 255, 255]
-    outputs.labels << [10,  60, "Music:  @mobypixel",     255, 255, 255]
-    outputs.labels << [10,  40, "Engine: DragonRuby GTK", 255, 255, 255]
-  end
+  # define the borders for where the crafting area is located
+  # the crafting area is below the inventory area
+  # the number 80 is the size of all the sprites, so that is what is being
+  # used to decide the with and height
+  args.state.craft_border.x =  10
+  args.state.craft_border.y = 220
+  args.state.craft_border.w = args.state.sprite_size * 3
+  args.state.craft_border.h = args.state.sprite_size * 3
 
-  def render_overlay
-    outputs.primitives << [grid.rect.scale_rect(1.1, 0, 0), 0, 0, 0, 230].solid
-  end
+  # define the area where results are located
+  # the crafting result is to the right of the craft area
+  args.state.result_border.x =  10 + args.state.sprite_size * 3 + args.state.sprite_size
+  args.state.result_border.y = 220 + args.state.sprite_size
+  args.state.result_border.w = args.state.sprite_size
+  args.state.result_border.h = args.state.sprite_size
 
-  def render_game
-    render_game_over
-    render_background
-    render_walls
-    render_dragon
-    render_flash
-  end
+  # initialize items for the first time if they are nil
+  # you start with 15 wood, 1 chest, and 5 plank
+  # Ruby has built in syntax for dictionaries (they look a lot like json objects).
+  # Ruby also has a special type called a Symbol denoted with a : followed by a word.
+  # Symbols are nice because they remove the need for magic strings.
+  if !args.state.items
+    args.state.items = [
+      {
+        id: :wood, # :wood is a Symbol, this is better than using "wood" for the id
+        quantity: 15,
+        path: 'sprites/wood.png',
+        location: :inventory,
+        ordinal_x: 0, ordinal_y: 0
+      },
+      {
+        id: :chest,
+        quantity: 1,
+        path: 'sprites/chest.png',
+        location: :inventory,
+        ordinal_x: 1, ordinal_y: 0
+      },
+      {
+        id: :plank,
+        quantity: 5,
+        path: 'sprites/plank.png',
+        location: :inventory,
+        ordinal_x: 2, ordinal_y: 0
+      },
+    ]
 
-  def render_game_over
-    return unless state.scene == :game
-    outputs.labels << [638, 358, score_text, 20, 1]
-    outputs.labels << [635, 360, score_text, 20, 1, 255, 255, 255]
-    outputs.labels << [638, 428, countdown_text, 20, 1]
-    outputs.labels << [635, 430, countdown_text, 20, 1, 255, 255, 255]
+    # after initializing the oridinal positions, derive the pixel
+    # locations assuming that the width and height are 80
+    args.state.items.each { |item| set_inventory_position args, item }
   end
 
-  def render_background
-    outputs.sprites << [0, 0, 1280, 720, 'sprites/background.png']
+  # define all the oridinal positions of the inventory slots
+  if !args.state.inventory_area
+    args.state.inventory_area = [
+      { ordinal_x: 0,  ordinal_y: 0 },
+      { ordinal_x: 1,  ordinal_y: 0 },
+      { ordinal_x: 2,  ordinal_y: 0 },
+      { ordinal_x: 3,  ordinal_y: 0 },
+      { ordinal_x: 4,  ordinal_y: 0 },
+      { ordinal_x: 5,  ordinal_y: 0 },
+      { ordinal_x: 6,  ordinal_y: 0 },
+      { ordinal_x: 7,  ordinal_y: 0 },
+      { ordinal_x: 8,  ordinal_y: 0 },
+      { ordinal_x: 9,  ordinal_y: 0 },
+      { ordinal_x: 0,  ordinal_y: 1 },
+      { ordinal_x: 1,  ordinal_y: 1 },
+      { ordinal_x: 2,  ordinal_y: 1 },
+      { ordinal_x: 3,  ordinal_y: 1 },
+      { ordinal_x: 4,  ordinal_y: 1 },
+      { ordinal_x: 5,  ordinal_y: 1 },
+      { ordinal_x: 6,  ordinal_y: 1 },
+      { ordinal_x: 7,  ordinal_y: 1 },
+      { ordinal_x: 8,  ordinal_y: 1 },
+      { ordinal_x: 9,  ordinal_y: 1 },
+      { ordinal_x: 0,  ordinal_y: 2 },
+      { ordinal_x: 1,  ordinal_y: 2 },
+      { ordinal_x: 2,  ordinal_y: 2 },
+      { ordinal_x: 3,  ordinal_y: 2 },
+      { ordinal_x: 4,  ordinal_y: 2 },
+      { ordinal_x: 5,  ordinal_y: 2 },
+      { ordinal_x: 6,  ordinal_y: 2 },
+      { ordinal_x: 7,  ordinal_y: 2 },
+      { ordinal_x: 8,  ordinal_y: 2 },
+      { ordinal_x: 9,  ordinal_y: 2 },
+    ]
 
-    scroll_point_at   = state.tick_count
-    scroll_point_at   = state.scene_at if state.scene == :menu
-    scroll_point_at   = state.death_at if state.countdown > 0
-    scroll_point_at ||= 0
+    # after initializing the oridinal positions, derive the pixel
+    # locations assuming that the width and height are 80
+    args.state.inventory_area.each { |i| set_inventory_position args, i }
 
-    outputs.sprites << scrolling_background(scroll_point_at, 'sprites/parallax_back.png',   0.25)
-    outputs.sprites << scrolling_background(scroll_point_at, 'sprites/parallax_middle.png', 0.50)
-    outputs.sprites << scrolling_background(scroll_point_at, 'sprites/parallax_front.png',  1.00, -80)
+    # if you want to see the result you can use the Ruby function called "puts".
+    # Uncomment this line to see the value.
+    # puts args.state.inventory_area
+
+    # You can see all things written via puts in DragonRuby's Console, or under logs/log.txt.
+    # To bring up DragonRuby's Console, press the ~ key within the game.
   end
 
-  def render_walls
-    state.walls.each do |w|
-      w.sprites = [
-        [w.x, w.bottom_height - 720, 100, 720, 'sprites/wall.png', 180],
-        [w.x, w.top_y,               100, 720, 'sprites/wallbottom.png', 0]
-      ]
-    end
-    outputs.sprites << state.walls.map(&:sprites)
+  # define all the oridinal positions of the craft slots
+  if !args.state.craft_area
+    args.state.craft_area = [
+      { ordinal_x: 0, ordinal_y: 0 },
+      { ordinal_x: 0, ordinal_y: 1 },
+      { ordinal_x: 0, ordinal_y: 2 },
+      { ordinal_x: 1, ordinal_y: 0 },
+      { ordinal_x: 1, ordinal_y: 1 },
+      { ordinal_x: 1, ordinal_y: 2 },
+      { ordinal_x: 2, ordinal_y: 0 },
+      { ordinal_x: 2, ordinal_y: 1 },
+      { ordinal_x: 2, ordinal_y: 2 },
+    ]
+
+    # after initializing the oridinal positions, derive the pixel
+    # locations assuming that the width and height are 80
+    args.state.craft_area.each { |c| set_craft_position args, c }
   end
+end
 
-  def render_dragon
-    state.show_death = true if state.countdown == 3.seconds
 
-    render_debug_hitbox false
+def render args
+  # for the results area, create a sprite that show its boundaries
+  args.outputs.primitives << { x: args.state.result_border.x,
+                               y: args.state.result_border.y,
+                               w: args.state.result_border.w,
+                               h: args.state.result_border.h,
+                               path: 'sprites/border-black.png' }
 
-    if state.show_death == false || !state.death_at
-      animation_index = state.flapped_at.frame_index 6, 2, false if state.flapped_at
-      sprite_name = "sprites/dragon_fly#{animation_index.or(0) + 1}.png"
-      state.dragon_sprite = [state.x, state.y, 100, 80, sprite_name, state.dy * 1.2]
-    else
-      sprite_name = "sprites/dragon_die.png"
-      state.dragon_sprite = [state.x, state.y, 100, 80, sprite_name, state.dy * 1.2]
-      sprite_changed_elapsed    = state.death_at.elapsed_time - 1.seconds
-      state.dragon_sprite.angle += (sprite_changed_elapsed ** 1.3) * state.death_fall_direction * -1
-      state.dragon_sprite.x     += (sprite_changed_elapsed ** 1.2) * state.death_fall_direction
-      state.dragon_sprite.y     += (sprite_changed_elapsed * 14 - sprite_changed_elapsed ** 1.6)
-    end
+  # for each inventory spot, create a sprite
+  # args.outputs.primitives is how DragonRuby performs a render.
+  # Adding a single hash or multiple hashes to this array will tell
+  # DragonRuby to render those primitives on that frame.
 
-    outputs.sprites << state.dragon_sprite
+  # The .map function on Array is used instead of any kind of looping.
+  # .map returns a new object for every object within an Array.
+  args.outputs.primitives << args.state.inventory_area.map do |a|
+    { x: a.x, y: a.y, w: a.w, h: a.h, path: 'sprites/border-black.png' }
   end
 
-  def render_debug_hitbox show
-    return unless show
-    outputs.borders << [dragon_collision_box.rect, 255, 0, 0] if state.dragon_sprite
-    outputs.borders << state.walls.flat_map do |w|
-       w.sprites.map { |s| [s.rect, 255, 0, 0] }
-    end
+  # for each craft spot, create a sprite
+  args.outputs.primitives << args.state.craft_area.map do |a|
+    { x: a.x, y: a.y, w: a.w, h: a.h, path: 'sprites/border-black.png' }
   end
 
-  def render_flash
-    return unless state.flash_at
-
-    outputs.primitives << [grid.rect,
-                           white,
-                           255 * state.flash_at.ease(20, :flip)].solid
+  # after the borders have been rendered, render the
+  # items within those slots (and allow for highlighting)
+  # if an item isn't currently being held
+  allow_inventory_highlighting = !args.state.held_item
 
-    state.flash_at = 0 if state.flash_at.elapsed_time > 20
-  end
+  # go through each item and render them
+  # use Array's find_all method to remove any items that are currently being held
+  args.state.items.find_all { |item| item[:location] != :held }.map do |item|
+    # if an item is currently being held, don't render it in it's spot within the
+    # inventory or craft area (this is handled via the find_all method).
 
-  def calc
-    return unless state.scene == :game
-    reset_game if state.countdown == 1
-    state.countdown -= 1 and return if state.countdown > 0
-    calc_walls
-    calc_flap
-    calc_game_over
+    # the item_prefab returns a hash containing all the visual components of an item.
+    # the main sprite, the black background, the quantity text, and a hover indication
+    # if the mouse is currently hovering over the item.
+    args.outputs.primitives << item_prefab(args, item, allow_inventory_highlighting, args.inputs.mouse)
   end
 
-  def calc_walls
-    state.walls.each { |w| w.x -= 8 }
+  # The last thing we want to render is the item currently being held.
+  args.outputs.primitives << item_prefab(args, args.state.held_item, allow_inventory_highlighting, args.inputs.mouse)
 
-    walls_count_before_removal = state.walls.length
+  args.outputs.primitives << args.state.click_ripples
 
-    state.walls.reject! { |w| w.x < -100 }
+  # render a mouse cursor since we have the OS cursor hidden
+  args.outputs.primitives << { x: args.inputs.mouse.x - 5, y: args.inputs.mouse.y - 5, w: 10, h: 10, path: 'sprites/circle-gray.png', a: 128 }
+end
 
-    state.score += 1 if state.walls.count < walls_count_before_removal
+# Alrighty! This is where all the fun happens
+def input args
+  # if the mouse is clicked and not item is currently being held
+  # args.state.held_item is nil when the game starts.
+  # If the player clicks, the property args.inputs.mouse.click will
+  # be a non nil value, we don't want to process any of the code here
+  # if the mouse hasn't been clicked
+  return if !args.inputs.mouse.click
 
-    state.wall_countdown -= 1 and return if state.wall_countdown > 0
+  # if a click occurred, add a ripple to the ripple queue
+  args.state.click_ripples << { x: args.inputs.mouse.x - 5, y: args.inputs.mouse.y - 5, w: 10, h: 10, path: 'sprites/circle-gray.png', a: 128 }
 
-    state.walls << state.new_entity(:wall) do |w|
-      w.x             = grid.right
-      w.opening       = grid.top
-                            .randomize(:ratio)
-                            .greater(200)
-                            .lesser(520)
-      w.bottom_height = w.opening - state.wall_gap_size
-      w.top_y         = w.opening + state.wall_gap_size
+  # if the mouse has been clicked, and no item is currently held...
+  if !args.state.held_item
+    # see if any of the items intersect the pointer using the inside_rect? method
+    # the find method will either return the first object that returns true
+    # for the match clause, or it'll return nil if nothing matches the match clause
+    found = args.state.items.find do |item|
+      # for each item in args.state.items, run the following boolean check
+      args.inputs.mouse.click.point.inside_rect?(item)
     end
 
-    state.wall_countdown = state.wall_countdown_length
-  end
+    # if an item intersects the mouse pointer, then set the item's location to :held and
+    # set args.state.held_item to the item for later reference
+    if found
+      args.state.held_item = found
+      found[:location] = :held
+    end
 
-  def calc_flap
-    state.y += state.dy
-    state.dy = state.dy.lesser state.flap_power
-    state.dy -= state.gravity
-    return if state.y < state.ceiling
-    state.y  = state.ceiling
-    state.dy = state.dy.lesser state.ceiling_flap_power
-  end
+  # if the mouse is clicked and an item is currently beign held....
+  elsif args.state.held_item
+    # determine if a slot within the craft area was clicked
+    craft_area = args.state.craft_area.find { |a| args.inputs.mouse.click.point.inside_rect? a }
 
-  def calc_game_over
-    return unless game_over?
+    # also determine if a slot within the inventory area was clicked
+    inventory_area = args.state.inventory_area.find { |a| args.inputs.mouse.click.point.inside_rect? a }
 
-    state.death_at = state.tick_count
-    state.death_from = state.walls.first
-    state.death_fall_direction = -1
-    state.death_fall_direction =  1 if state.x > state.death_from.x
-    outputs.sounds << "sounds/hit-sound.wav"
-    begin_countdown
-  end
+    # if the click was within a craft area
+    if craft_area
+      # check to see if an item is already there and ignore the click if an item is found
+      # item_at_craft_slot is a helper method that returns an item or nil for a given oridinal
+      # position
+      item_already_there = item_at_craft_slot args, craft_area[:ordinal_x], craft_area[:ordinal_y]
 
-  def process_inputs
-    process_inputs_menu
-    process_inputs_game
-  end
+      # if an item *doesn't* exist in the craft area
+      if !item_already_there
+        # if the quantity they are currently holding is greater than 1
+        if args.state.held_item[:quantity] > 1
+          # remove one item (creating a seperate item of the same type), and place it
+          # at the oridinal position and location of the craft area
+          # the .merge method on Hash creates a new Hash, but updates any values
+          # passed as arguments to merge
+          new_item = args.state.held_item.merge(quantity: 1,
+                                                location: :craft,
+                                                ordinal_x: craft_area[:ordinal_x],
+                                                ordinal_y: craft_area[:ordinal_y])
 
-  def process_inputs_menu
-    return unless state.scene == :menu
+          # after the item is crated, place it into the args.state.items collection
+          args.state.items << new_item
 
-    changediff = inputs.keyboard.key_down.tab || inputs.controller_one.key_down.select
-    if inputs.mouse.click
-      p = inputs.mouse.click.point
-      if (p.y >= 165) && (p.y < 200) && (p.x >= 500) && (p.x < 800)
-        changediff = true
-      end
-    end
+          # then subtract one from the held item
+          args.state.held_item[:quantity] -= 1
 
-    if changediff
-      case state.new_difficulty
-      when :easy
-        state.new_difficulty = :normal
-      when :normal
-        state.new_difficulty = :hard
-      when :hard
-        state.new_difficulty = :flappy
-      when :flappy
-        state.new_difficulty = :easy
+        # if the craft area is available and there is only one item being held
+        elsif args.state.held_item[:quantity] == 1
+          # instead of creating any new items just set the location of the held item
+          # to the oridinal position of the craft area, and then nil out the
+          # held item state so that a new item can be picked up
+          args.state.held_item[:location] = :craft
+          args.state.held_item[:ordinal_x] = craft_area[:ordinal_x]
+          args.state.held_item[:ordinal_y] = craft_area[:ordinal_y]
+          args.state.held_item = nil
+        end
       end
-    end
 
-    if inputs.keyboard.key_down.enter || inputs.controller_one.key_down.start || inputs.controller_one.key_down.a
-      state.difficulty = state.new_difficulty
-      change_to_scene :game
-      reset_game false
-      state.hi_score = 0
-      begin_countdown
-    end
+    # if the selected area is an inventory area (as opposed to within the craft area)
+    elsif inventory_area
 
-    if inputs.keyboard.key_down.escape || (inputs.mouse.click && !changediff) || inputs.controller_one.key_down.b
-      state.new_difficulty = state.difficulty
-      change_to_scene :game
-    end
-  end
+      # check to see if there is already an item in that inventory slot
+      # the item_at_inventory_slot helper method returns an item or nil
+      item_already_there = item_at_inventory_slot args, inventory_area[:ordinal_x], inventory_area[:ordinal_y]
 
-  def process_inputs_game
-    return unless state.scene == :game
+      # if there is already an item there, and the item types/id match
+      if item_already_there && item_already_there[:id] == args.state.held_item[:id]
+        # then merge the item quantities
+        held_quantity = args.state.held_item[:quantity]
+        item_already_there[:quantity] += held_quantity
 
-    clicked_menu = false
-    if inputs.mouse.click
-      p = inputs.mouse.click.point
-      clicked_menu = (p.y >= 620) && (p.x < 275)
-    end
+        # remove the item being held from the items collection (since it's quantity is now 0)
+        args.state.items.reject! { |i| i[:location] == :held }
 
-    if clicked_menu || inputs.keyboard.key_down.escape || inputs.keyboard.key_down.enter || inputs.controller_one.key_down.start
-      change_to_scene :menu
-    elsif (inputs.mouse.down || inputs.mouse.click || inputs.keyboard.key_down.space || inputs.controller_one.key_down.a) && state.countdown == 0
-      state.dy = 0
-      state.dy += state.flap_power
-      state.flapped_at = state.tick_count
-      outputs.sounds << "sounds/fly-sound.wav"
-    end
-  end
+        # nil out the held_item so a new item can be picked up
+        args.state.held_item = nil
 
-  def scrolling_background at, path, rate, y = 0
-    [
-      [   0 - at.*(rate) % 1440, y, 1440, 720, path],
-      [1440 - at.*(rate) % 1440, y, 1440, 720, path]
-    ]
-  end
+      # if there currently isn't an item there, then put the held item in the slot
+      elsif !item_already_there
+        args.state.held_item[:location] = :inventory
+        args.state.held_item[:ordinal_x] = inventory_area[:ordinal_x]
+        args.state.held_item[:ordinal_y] = inventory_area[:ordinal_y]
 
-  def white
-    [255, 255, 255]
+        # nil out the held_item so a new item can be picked up
+        args.state.held_item = nil
+      end
+    end
   end
+end
 
-  def large_white_typeset
-    [5, 0, 255, 255, 255]
+# the calc method is executed after input
+def calc args
+  # make sure that the real position of the inventory
+  # items are updated every frame to ensure that they
+  # are placed correctly given their location and oridinal positions
+  # instead of using .map, here we use .each (since we are not returning a new item and just updating the items in place)
+  args.state.items.each do |item|
+    # based on the location of the item, invoke the correct pixel conversion method
+    if item[:location] == :inventory
+      set_inventory_position args, item
+    elsif item[:location] == :craft
+      set_craft_position args, item
+    elsif item[:location] == :held
+      # if the item is held, center the item around the mouse pointer
+      args.state.held_item.x = args.inputs.mouse.x - args.state.held_item.w.half
+      args.state.held_item.y = args.inputs.mouse.y - args.state.held_item.h.half
+    end
   end
 
-  def at_beginning?
-    state.walls.count == 0
+  # for each hash/sprite in the click ripples queue,
+  # expand its size by 20 percent and decrease its alpha
+  # by 10.
+  args.state.click_ripples.each do |ripple|
+    delta_w = ripple.w * 1.2 - ripple.w
+    delta_h = ripple.h * 1.2 - ripple.h
+    ripple.x -= delta_w.half
+    ripple.y -= delta_h.half
+    ripple.w += delta_w
+    ripple.h += delta_h
+    ripple.a -= 10
   end
 
-  def dragon_collision_box
-    state.dragon_sprite
-        .scale_rect(1.0 - collision_forgiveness, 0.5, 0.5)
-        .rect_shift_right(10)
-        .rect_shift_up(state.dy * 2)
-  end
+  # remove any items from the collection where the alpha value is less than equal to
+  # zero using the reject! method (reject with an exclamation point at the end changes the
+  # array value in place, while reject without the exclamation point returns a new array).
+  args.state.click_ripples.reject! { |ripple| ripple.a <= 0 }
+end
 
-  def game_over?
-    return true if state.y <= 0.-(500 * collision_forgiveness) && !at_beginning?
+# helper function for finding an item at a craft slot
+def item_at_craft_slot args, ordinal_x, ordinal_y
+  args.state.items.find { |i| i[:location] == :craft && i[:ordinal_x] == ordinal_x && i[:ordinal_y] == ordinal_y }
+end
 
-    state.walls
-        .flat_map { |w| w.sprites }
-        .any? do |s|
-          s.intersect_rect?(dragon_collision_box)
-        end
-  end
+# helper function for finding an item at an inventory slot
+def item_at_inventory_slot args, ordinal_x, ordinal_y
+  args.state.items.find { |i| i[:location] == :inventory && i[:ordinal_x] == ordinal_x && i[:ordinal_y] == ordinal_y }
+end
 
-  def collision_forgiveness
-    case state.difficulty
-    when :easy
-      0.9
-    when :normal
-      0.7
-    when :hard
-      0.5
-    when :flappy
-      0.3
-    else
-      0.9
-    end
-  end
+# helper function that creates a visual representation of an item
+def item_prefab args, item, should_highlight, mouse
+  return nil unless item
 
-  def countdown_text
-    state.countdown ||= -1
-    return ""          if state.countdown == 0
-    return "GO!"       if state.countdown.idiv(60) == 0
-    return "GAME OVER" if state.death_at
-    return "READY?"
-  end
+  overlay = nil
 
-  def begin_countdown
-    state.countdown = 4.seconds
-  end
+  x = item.x
+  y = item.y
+  w = item.w
+  h = item.h
 
-  def score_text
-    return ""                        unless state.countdown > 1.seconds
-    return ""                        unless state.death_at
-    return "SCORE: 0 (LOL)"          if state.score == 0
-    return "HI SCORE: #{state.score}" if state.score == state.hi_score
-    return "SCORE: #{state.score}"
+  if should_highlight && mouse.point.inside_rect?(item)
+    overlay = { x: x, y: y, w: w, h: h, path: "sprites/square-blue.png", a: 130, }
   end
 
-  def reset_game set_flash = true
-    state.flash_at = state.tick_count if set_flash
-    state.walls = []
-    state.y = 500
-    state.dy = 0
-    state.hi_score = state.hi_score.greater(state.score)
-    state.score = 0
-    state.wall_countdown = state.wall_countdown_length.fdiv(2)
-    state.show_death = false
-    state.death_at = nil
-  end
+  [
+    # sprites are hashes with a path property, this is the main sprite
+    { x: x,      y: y, w: args.state.sprite_size, h: args.state.sprite_size, path: item[:path], },
 
-  def change_to_scene scene
-    state.scene = scene
-    state.scene_at = state.tick_count
-    inputs.keyboard.clear
-    inputs.controller_one.clear
-  end
-end
+    # this represents the black area in the bottom right corner of the main sprite so that the
+    # quantity is visible
+    { x: x + 55, y: y, w: 25, h: 25, path: "sprites/square-black.png", }, # sprites are hashes with a path property
 
-$flappy_dragon = FlappyDragon.new
+    # labels are hashes with a text property
+    { x: x + 56, y: y + 22, text: "#{item[:quantity]}", r: 255, g: 255, b: 255, },
 
-def tick args
-  $flappy_dragon.grid = args.grid
-  $flappy_dragon.inputs = args.inputs
-  $flappy_dragon.state = args.state
-  $flappy_dragon.outputs = args.outputs
-  $flappy_dragon.tick
+    # this is the mouse overlay, if the overlay isn't applicable, then this value will be nil (nil values will not be rendered)
+    overlay
+  ]
 end
 
-
-Arcade - Pong - main.rb
-# ./samples/99_genre_arcade/pong/app/main.rb
-def tick args
-  defaults args
-  render args
-  calc args
-  input args
+# helper function for deriving the position of an item within inventory
+def set_inventory_position args, item
+  item.x = args.state.inventory_border.x + item[:ordinal_x] * 80
+  item.y = (args.state.inventory_border.y + args.state.inventory_border.h - 80) - item[:ordinal_y] * 80
+  item.w = 80
+  item.h = 80
 end
 
-def defaults args
-  args.state.ball.debounce       ||= 3 * 60
-  args.state.ball.size           ||= 10
-  args.state.ball.size_half      ||= args.state.ball.size / 2
-  args.state.ball.x              ||= 640
-  args.state.ball.y              ||= 360
-  args.state.ball.dx             ||= 5.randomize(:sign)
-  args.state.ball.dy             ||= 5.randomize(:sign)
-  args.state.left_paddle.y       ||= 360
-  args.state.right_paddle.y      ||= 360
-  args.state.paddle.h            ||= 120
-  args.state.paddle.w            ||= 10
-  args.state.left_paddle.score   ||= 0
-  args.state.right_paddle.score  ||= 0
+# helper function for deriving the position of an item within the craft area
+def set_craft_position args, item
+  item.x = args.state.craft_border.x + item[:ordinal_x] * 80
+  item.y = (args.state.craft_border.y + args.state.inventory_border.h - 80) - item[:ordinal_y] * 80
+  item.w = 80
+  item.h = 80
 end
 
-def render args
-  render_center_line args
-  render_scores args
-  render_countdown args
-  render_ball args
-  render_paddles args
-  render_instructions args
-end
+# Any lines outside of a function will be executed when the file is reloaded.
+# So every time you save main.rb, the game will be reset.
+# Comment out the line below if you don't want this to happen.
+$gtk.reset
 
-begin :render_methods
-  def render_center_line args
-    args.outputs.lines  << [640, 0, 640, 720]
-  end
+
+Dev Tools - Add Buttons To Console - main.rb
+# ./samples/99_genre_dev_tools/add_buttons_to_console/app/main.rb
+# You can customize the buttons that show up in the Console.
+class GTK::Console::Menu
+  # STEP 1: Override the custom_buttons function.
+  def custom_buttons
+    [
+      (button id: :yay,
+              # row for button
+              row: 3,
+              # column for button
+              col: 10,
+              # text
+              text: "I AM CUSTOM",
+              # when clicked call the custom_button_clicked function
+              method: :custom_button_clicked),
 
-  def render_scores args
-    args.outputs.labels << [
-      [320, 650, args.state.left_paddle.score, 10, 1],
-      [960, 650, args.state.right_paddle.score, 10, 1]
+      (button id: :yay,
+              # row for button
+              row: 3,
+              # column for button
+              col: 9,
+              # text
+              text: "CUSTOM ALSO",
+              # when clicked call the custom_button_also_clicked function
+              method: :custom_button_also_clicked)
     ]
   end
 
-  def render_countdown args
-    return unless args.state.ball.debounce > 0
-    args.outputs.labels << [640, 360, "%.2f" % args.state.ball.debounce.fdiv(60), 10, 1]
+  # STEP 2: Define the function that should be called.
+  def custom_button_clicked
+    log "* INFO: I AM CUSTOM was clicked!"
   end
 
-  def render_ball args
-    args.outputs.solids << solid_ball(args)
-  end
+  def custom_button_also_clicked
+    log "* INFO: Custom Button Clicked at #{Kernel.global_tick_count}!"
 
-  def render_paddles args
-    args.outputs.solids << solid_left_paddle(args)
-    args.outputs.solids << solid_right_paddle(args)
-  end
+    all_buttons_as_string = $gtk.console.menu.buttons.map do |b|
+      <<-S.strip
+** id: #{b[:id]}
+:PROPERTIES:
+:id:     :#{b[:id]}
+:method: :#{b[:method]}
+:text:   #{b[:text]}
+:END:
+S
+    end.join("\n")
 
-  def render_instructions args
-    args.outputs.labels << [320, 30, "W and S keys to move left paddle.",  0, 1]
-    args.outputs.labels << [920, 30, "O and L keys to move right paddle.", 0, 1]
+    log <<-S
+* INFO: Here are all the buttons:
+#{all_buttons_as_string}
+S
   end
 end
 
-def calc args
-  args.state.ball.debounce -= 1 and return if args.state.ball.debounce > 0
-  calc_move_ball args
-  calc_collision_with_left_paddle args
-  calc_collision_with_right_paddle args
-  calc_collision_with_walls args
-end
+def tick args
+  args.outputs.labels << [args.grid.center.x, args.grid.center.y,
+                          "Open the DragonRuby Console to see the custom menu items.",
+                          0, 1]
+end
+
+
+Dev Tools - Animation Creator Starting Point - main.rb
+# ./samples/99_genre_dev_tools/animation_creator_starting_point/app/main.rb
+class OneBitLowrezPaint
+  attr_gtk
 
-begin :calc_methods
-  def calc_move_ball args
-    args.state.ball.x += args.state.ball.dx
-    args.state.ball.y += args.state.ball.dy
+  def tick
+    outputs.background_color = [0, 0, 0]
+    defaults
+    render_instructions
+    render_canvas
+    render_buttons_frame_selection
+    render_animation_frame_thumbnails
+    render_animation
+    input_mouse_click
+    input_keyboard
+    calc_auto_export
+    calc_buttons_frame_selection
+    calc_animation_frames
+    process_queue_create_sprite
+    process_queue_reset_sprite
+    process_queue_update_rt_animation_frame
   end
 
-  def calc_collision_with_left_paddle args
-    if solid_left_paddle(args).intersect_rect? solid_ball(args)
-      args.state.ball.dx *= -1
-    elsif args.state.ball.x < 0
-      args.state.right_paddle.score += 1
-      calc_reset_round args
-    end
-  end
+  def defaults
+    state.animation_frames_per_second = 12
+    queues.create_sprite ||= []
+    queues.reset_sprite ||= []
+    queues.update_rt_animation_frame ||= []
 
-  def calc_collision_with_right_paddle args
-    if solid_right_paddle(args).intersect_rect? solid_ball(args)
-      args.state.ball.dx *= -1
-    elsif args.state.ball.x > 1280
-      args.state.left_paddle.score += 1
-      calc_reset_round args
+    if !state.animation_frames
+      state.animation_frames ||= []
+      add_animation_frame_to_end
     end
-  end
 
-  def calc_collision_with_walls args
-    if args.state.ball.y + args.state.ball.size_half > 720
-      args.state.ball.y = 720 - args.state.ball.size_half
-      args.state.ball.dy *= -1
-    elsif args.state.ball.y - args.state.ball.size_half < 0
-      args.state.ball.y = args.state.ball.size_half
-      args.state.ball.dy *= -1
-    end
-  end
+    state.last_mouse_down ||= 0
+    state.last_mouse_up   ||= 0
 
-  def calc_reset_round args
-    args.state.ball.x = 640
-    args.state.ball.y = 360
-    args.state.ball.dx = 5.randomize(:sign)
-    args.state.ball.dy = 5.randomize(:sign)
-    args.state.ball.debounce = 3 * 60
+    state.buttons_frame_selection.left = 10
+    state.buttons_frame_selection.top  = grid.top - 10
+    state.buttons_frame_selection.size = 20
+
+    defaults_canvas_sprite
+
+    state.edit_mode ||= :drawing
   end
-end
 
-def input args
-  input_left_paddle args
-  input_right_paddle args
-end
+  def defaults_canvas_sprite
+    rt_canvas.size   = 16
+    rt_canvas.zoom   = 30
+    rt_canvas.width  = rt_canvas.size * rt_canvas.zoom
+    rt_canvas.height = rt_canvas.size * rt_canvas.zoom
+    rt_canvas.sprite = { x: 0,
+                         y: 0,
+                         w: rt_canvas.width,
+                         h: rt_canvas.height,
+                         path: :rt_canvas }.center_inside_rect(x: 0, y: 0, w: 640, h: 720)
 
-begin :input_methods
-  def input_left_paddle args
-    if args.inputs.controller_one.key_down.down  || args.inputs.keyboard.key_down.s
-      args.state.left_paddle.y -= 40
-    elsif args.inputs.controller_one.key_down.up || args.inputs.keyboard.key_down.w
-      args.state.left_paddle.y += 40
+    return unless state.tick_count == 1
+
+    outputs[:rt_canvas].width      = rt_canvas.width
+    outputs[:rt_canvas].height     = rt_canvas.height
+    outputs[:rt_canvas].sprites   << (rt_canvas.size + 1).map_with_index do |x|
+      (rt_canvas.size + 1).map_with_index do |y|
+        path = 'sprites/square-white.png'
+        path = 'sprites/square-blue.png' if x == 7 || x == 8
+        { x: x * rt_canvas.zoom,
+          y: y * rt_canvas.zoom,
+          w: rt_canvas.zoom,
+          h: rt_canvas.zoom,
+          path: path,
+          a: 50 }
+      end
     end
   end
 
-  def input_right_paddle args
-    if args.inputs.controller_two.key_down.down  || args.inputs.keyboard.key_down.l
-      args.state.right_paddle.y -= 40
-    elsif args.inputs.controller_two.key_down.up || args.inputs.keyboard.key_down.o
-      args.state.right_paddle.y += 40
+  def render_instructions
+    instructions = [
+      "* Hotkeys:",
+      "- d: hold to erase, release to draw.",
+      "- a: add frame.",
+      "- c: copy frame.",
+      "- v: paste frame.",
+      "- x: delete frame.",
+      "- b: go to previous frame.",
+      "- f: go to next frame.",
+      "- w: save to ./canvas directory.",
+      "- l: load from ./canvas."
+    ]
+
+    instructions.each.with_index do |l, i|
+      outputs.labels << { x: 840, y: 500 - (i * 20), text: "#{l}",
+                          r: 180, g: 180, b: 180, size_enum: 0 }
     end
   end
-end
 
-begin :assets
-  def solid_ball args
-    centered_rect args.state.ball.x, args.state.ball.y, args.state.ball.size, args.state.ball.size
+  def render_canvas
+    return if state.tick_count.zero?
+    outputs.sprites << rt_canvas.sprite
   end
 
-  def solid_left_paddle args
-    centered_rect_vertically 0, args.state.left_paddle.y, args.state.paddle.w, args.state.paddle.h
-  end
+  def render_buttons_frame_selection
+    args.outputs.primitives << state.buttons_frame_selection.items.map_with_index do |b, i|
+      label = { x: b.x + state.buttons_frame_selection.size.half,
+                y: b.y,
+                text: "#{i + 1}", r: 180, g: 180, b: 180,
+                size_enum: -4, alignment_enum: 1 }.label
 
-  def solid_right_paddle args
-    centered_rect_vertically 1280 - args.state.paddle.w, args.state.right_paddle.y, args.state.paddle.w, args.state.paddle.h
-  end
+      selection_border = b.merge(r: 40, g: 40, b: 40).border
 
-  def centered_rect x, y, w, h
-    [x - w / 2, y - h / 2, w, h]
-  end
+      if i == state.animation_frames_selected_index
+        selection_border = b.merge(r: 40, g: 230, b: 200).border
+      end
 
-  def centered_rect_vertically x, y, w, h
-    [x, y - h / 2, w, h]
+      [selection_border, label]
+    end
   end
-end
 
-

-Arcade - Snakemoji - main.rb
-# ./samples/99_genre_arcade/snakemoji/app/main.rb
-# coding: utf-8
-################################
-#  So I was working on a snake game while
-#  learning DragonRuby, and at some point I had a thought
-#  what if I use "😀" as a function name, surely it wont work right...?
-#  RIGHT....?
-#  BUT IT DID, IT WORKED
-#  it all went downhill from then
-#  Created by Anton K. (ai Doge)
-#  https://gist.github.com/scorp200
-#############LICENSE############
-#  Feel free to use this anywhere and however you want
-#  You can sell this to EA for $1,000,000 if you want, its completely free.
-#  Just rememeber you are helping this... thing... to spread...
-#  ALSO! I am not liable for any mental, physical or financial damage caused.
-#############LICENSE############
+  def render_animation_frame_thumbnails
+    return if state.tick_count.zero?
 
+    outputs[:current_animation_frame].width   = rt_canvas.size
+    outputs[:current_animation_frame].height  = rt_canvas.size
+    outputs[:current_animation_frame].solids <<  selected_animation_frame[:pixels].map_with_index do |f, i|
+      { x: f.x,
+        y: f.y,
+        w: 1,
+        h: 1, r: 255, g: 255, b: 255 }
+    end
 
-class Array
-  #Helper function
-  def move! vector
-    self.x += vector.x
-    self.y += vector.y
-    return self
-  end
+    outputs.sprites << rt_canvas.sprite.merge(path: :current_animation_frame)
 
-  #Helper function to draw snake body
-  def draw! 🎮, 📺, color
-    translate 📺.solids, 🎮.⛓, [self.x * 🎮.⚖️ + 🎮.🛶 / 2, self.y * 🎮.⚖️ + 🎮.🛶 / 2, 🎮.⚖️ - 🎮.🛶, 🎮.⚖️ - 🎮.🛶, color]
+    state.animation_frames.map_with_index do |animation_frame, animation_frame_index|
+      outputs.sprites << state.buttons_frame_selection[:items][animation_frame_index][:inner_rect]
+                              .merge(path: animation_frame[:rt_name])
+    end
   end
 
-  #This is where it all started, I was trying to find  good way to multiply a map by a number, * is already used so is **
-  #I kept trying different combinations of symbols, when suddenly...
-  def 😀 value
-    self.map {|d| d * value}
-  end
-end
+  def render_animation
+    sprite_index = 0.frame_index count: state.animation_frames.length,
+                                 hold_for: 60 / state.animation_frames_per_second,
+                                 repeat: true
 
-#Draw stuff with an offset
-def translate output_collection, ⛓, what
-  what.x += ⛓.x
-  what.y += ⛓.y
-  output_collection << what
-end
+    args.outputs.sprites << { x: 700 - 8,
+                              y: 120,
+                              w: 16,
+                              h: 16,
+                              path: (sprite_path sprite_index) }
 
-BLUE = [33, 150, 243]
-RED = [244, 67, 54]
-GOLD = [255, 193, 7]
-LAST = 0
+    args.outputs.sprites << { x: 700 - 16,
+                              y: 230,
+                              w: 32,
+                              h: 32,
+                              path: (sprite_path sprite_index) }
 
-def tick args
-  defaults args.state
-  render args.state, args.outputs
-  input args.state, args.inputs
-  update args.state
-end
+    args.outputs.sprites << { x: 700 - 32,
+                              y: 360,
+                              w: 64,
+                              h: 64,
+                              path: (sprite_path sprite_index) }
 
-def update 🎮
-  #Update every 10 frames
-  if 🎮.tick_count.mod_zero? 10
-    #Add new snake body piece at head's location
-    🎮.🐍 << [*🎮.🤖]
-    #Assign Next Direction to Direction
-    🎮.🚗 = *🎮.🚦
+    args.outputs.sprites << { x: 700 - 64,
+                              y: 520,
+                              w: 128,
+                              h: 128,
+                              path: (sprite_path sprite_index) }
+  end
 
-    #Trim the snake a bit if its longer than current size
-    if 🎮.🐍.length > 🎮.🛒
-      🎮.🐍 = 🎮.🐍[-🎮.🛒..-1]
+  def input_mouse_click
+    if inputs.mouse.up
+      state.last_mouse_up = state.tick_count
+    elsif inputs.mouse.moved && user_is_editing?
+      edit_current_animation_frame inputs.mouse.point
     end
 
-    #Move the head in the Direction
-    🎮.🤖.move! 🎮.🚗
+    return unless inputs.mouse.click
 
-    #If Head is outside the playing field, or inside snake's body restart game
-    if 🎮.🤖.x < 0 || 🎮.🤖.x >= 🎮.🗺.x || 🎮.🤖.y < 0 || 🎮.🤖.y >= 🎮.🗺.y || 🎮.🚗 != [0, 0] && 🎮.🐍.any? {|s| s == 🎮.🤖}
-      LAST = 🎮.💰
-      🎮.as_hash.clear
-      return
+    clicked_frame_button = state.buttons_frame_selection.items.find do |b|
+      inputs.mouse.point.inside_rect? b
     end
 
-    #If head lands on food add size and score
-    if 🎮.🤖 == 🎮.🍎
-      🎮.🛒 += 1
-      🎮.💰 += (🎮.🛒 * 0.8).floor.to_i + 5
-      spawn_🍎 🎮
-      puts 🎮.🍎
+    if (clicked_frame_button)
+      state.animation_frames_selected_index = clicked_frame_button[:index]
     end
-  end
 
-  #Every second remove 1 point
-  if 🎮.💰 > 0 && 🎮.tick_count.mod_zero?(60)
-    🎮.💰 -= 1
+    if (inputs.mouse.point.inside_rect? rt_canvas.sprite)
+      state.last_mouse_down = state.tick_count
+      edit_current_animation_frame inputs.mouse.point
+    end
   end
-end
 
-def spawn_🍎 🎮
-  #Food
-  🎮.🍎 ||= [*🎮.🤖]
-  #Randomly spawns food inside the playing field, keep doing this if the food keeps landing on the snake's body
-  while 🎮.🐍.any? {|s| s == 🎮.🍎} || 🎮.🍎 == 🎮.🤖 do
-    🎮.🍎 = [rand(🎮.🗺.x), rand(🎮.🗺.y)]
-  end
-end
+  def input_keyboard
+    # w to save
+    if inputs.keyboard.key_down.w
+      t = Time.now
+      state.save_description = "Time: #{t} (#{t.to_i})"
+      gtk.serialize_state 'canvas/state.txt', state
+      gtk.serialize_state "tmp/canvas_backups/#{t.to_i}/state.txt", state
+      animation_frames.each_with_index do |animation_frame, i|
+        queues.update_rt_animation_frame << { index: i,
+                                              at: state.tick_count + i,
+                                              queue_sprite_creation: true }
+        queues.create_sprite << { index: i,
+                                  at: state.tick_count + animation_frames.length + i,
+                                  path_override: "tmp/canvas_backups/#{t.to_i}/sprite-#{i}.png" }
+      end
+      gtk.notify! "Canvas saved."
+    end
 
-def render 🎮, 📺
-  #Paint the background black
-  📺.solids << [0, 0, 1280, 720, 0, 0, 0, 255]
-  #Draw a border for the playing field
-  translate 📺.borders, 🎮.⛓, [0, 0, 🎮.🗺.x * 🎮.⚖️, 🎮.🗺.y * 🎮.⚖️, 255, 255, 255]
+    # l to load
+    if inputs.keyboard.key_down.l
+      args.state = gtk.deserialize_state 'canvas/state.txt'
+      animation_frames.each_with_index do |a, i|
+        queues.update_rt_animation_frame << { index: i,
+                                              at: state.tick_count + i,
+                                              queue_sprite_creation: true }
+      end
+      gtk.notify! "Canvas loaded."
+    end
 
-  #Draw the snake's body
-  🎮.🐍.map do |🐍| 🐍.draw! 🎮, 📺, BLUE end
-  #Draw the head
-  🎮.🤖.draw! 🎮, 📺, BLUE
-  #Draw the food
-  🎮.🍎.draw! 🎮, 📺, RED
+    # d to go into delete mode, release to paint
+    if inputs.keyboard.key_held.d
+      state.edit_mode = :erasing
+      gtk.notify! "Erasing." if inputs.keyboard.key_held.d == (state.tick_count - 1)
+    elsif inputs.keyboard.key_up.d
+      state.edit_mode = :drawing
+      gtk.notify! "Drawing."
+    end
 
-  #Draw current score
-  translate 📺.labels, 🎮.⛓, [5, 715, "Score: #{🎮.💰}", GOLD]
-  #Draw your last score, if any
-  translate 📺.labels, 🎮.⛓, [[*🎮.🤖.😀(🎮.⚖️)].move!([0, 🎮.⚖️ * 2]), "Your Last score is #{LAST}", 0, 1, GOLD] unless LAST == 0 || 🎮.🚗 != [0, 0]
-  #Draw starting message, only if Direction is 0
-  translate 📺.labels, 🎮.⛓, [🎮.🤖.😀(🎮.⚖️), "Press any Arrow key to start", 0, 1, GOLD] unless 🎮.🚗 != [0, 0]
-end
+    # a to add a frame to the end
+    if inputs.keyboard.key_down.a
+      queues.create_sprite << { index: state.animation_frames_selected_index,
+                                at: state.tick_count }
+      queues.create_sprite << { index: state.animation_frames_selected_index + 1,
+                                at: state.tick_count }
+      add_animation_frame_to_end
+      gtk.notify! "Frame added to end."
+    end
 
-def input 🎮, 🕹
-  #Left and Right keyboard input, only change if X direction is 0
-  if 🕹.keyboard.key_held.left && 🎮.🚗.x == 0
-    🎮.🚦 = [-1, 0]
-  elsif 🕹.keyboard.key_held.right && 🎮.🚗.x == 0
-    🎮.🚦 = [1, 0]
-  end
+    # c or t to copy
+    if (inputs.keyboard.key_down.c || inputs.keyboard.key_down.t)
+      state.clipboard = [selected_animation_frame[:pixels]].flatten
+      gtk.notify! "Current frame copied."
+    end
 
-  #Up and Down keyboard input, only change if Y direction is 0
-  if 🕹.keyboard.key_held.up && 🎮.🚗.y == 0
-    🎮.🚦 = [0, 1]
-  elsif 🕹.keyboard.key_held.down && 🎮.🚗.y == 0
-    🎮.🚦 = [0, -1]
-  end
-end
+    # v or q to paste
+    if (inputs.keyboard.key_down.v || inputs.keyboard.key_down.q) && state.clipboard
+      selected_animation_frame[:pixels] = [state.clipboard].flatten
+      queues.update_rt_animation_frame << { index: state.animation_frames_selected_index,
+                                            at: state.tick_count,
+                                            queue_sprite_creation: true }
+      gtk.notify! "Pasted."
+    end
 
-def defaults 🎮
-  #Playing field size
-  🎮.🗺 ||= [20, 20]
-  #Scale for drawing, screen height / Field height
-  🎮.⚖️ ||= 720 / 🎮.🗺.y
-  #Offset, offset all rendering to the center of the screen
-  🎮.⛓ ||= [(1280 - 720).fdiv(2), 0]
-  #Padding, make the snake body slightly smaller than the scale
-  🎮.🛶 ||= (🎮.⚖️ * 0.2).to_i
-  #Snake Size
-  🎮.🛒 ||= 3
-  #Snake head, the only part we are actually controlling
-  🎮.🤖 ||= [🎮.🗺.x / 2, 🎮.🗺.y / 2]
-  #Snake body map, follows the head
-  🎮.🐍 ||= []
-  #Direction the head moves to
-  🎮.🚗 ||= [0, 0]
-  #Next_Direction, during input check only change this variable and then when game updates asign this to Direction
-  🎮.🚦 ||= [*🎮.🚗]
-  #Your score
-  🎮.💰 ||= 0
-  #Spawns Food randomly
-  spawn_🍎(🎮) unless 🎮.🍎?
-end
+    # f to go forward/next frame
+    if (inputs.keyboard.key_down.f)
+      if (state.animation_frames_selected_index == (state.animation_frames.length - 1))
+        state.animation_frames_selected_index = 0
+      else
+        state.animation_frames_selected_index += 1
+      end
+      gtk.notify! "Next frame."
+    end
 
-
-Arcade - Solar System - main.rb
-# ./samples/99_genre_arcade/solar_system/app/main.rb
-# Focused tutorial video: https://s3.amazonaws.com/s3.dragonruby.org/dragonruby-nddnug-workshop.mp4
-# Workshop/Presentation which provides motivation for creating a game engine: https://www.youtube.com/watch?v=S3CFce1arC8
+    # b to go back/previous frame
+    if (inputs.keyboard.key_down.b)
+      if (state.animation_frames_selected_index == 0)
+        state.animation_frames_selected_index = state.animation_frames.length - 1
+      else
+        state.animation_frames_selected_index -= 1
+      end
+      gtk.notify! "Previous frame."
+    end
 
-def defaults args
-  args.outputs.background_color = [0, 0, 0]
-  args.state.x ||= 640
-  args.state.y ||= 360
-  args.state.stars ||= 100.map do
-    [1280 * rand, 720 * rand, rand.fdiv(10), 255 * rand, 255 * rand, 255 * rand]
+    # x to delete frame
+    if (inputs.keyboard.key_down.x) && animation_frames.length > 1
+      state.clipboard = selected_animation_frame[:pixels]
+      state.animation_frames = animation_frames.find_all { |v| v[:index] != state.animation_frames_selected_index }
+      if state.animation_frames_selected_index >= state.animation_frames.length
+        state.animation_frames_selected_index = state.animation_frames.length - 1
+      end
+      gtk.notify! "Frame deleted."
+    end
   end
 
-  args.state.sun ||= args.state.new_entity(:sun) do |s|
-    s.s = 100
-    s.path = 'sprites/sun.png'
+  def calc_auto_export
+    return if user_is_editing?
+    return if state.last_mouse_up.elapsed_time != 30
+    # auto export current animation frame if there is no editing for 30 ticks
+    queues.create_sprite << { index: state.animation_frames_selected_index,
+                              at: state.tick_count }
   end
 
-  args.state.planets = [
-    [:mercury,   65,  5,          88],
-    [:venus,    100, 10,         225],
-    [:earth,    120, 10,         365],
-    [:mars,     140,  8,         687],
-    [:jupiter,  280, 30, 365 *  11.8],
-    [:saturn,   350, 20, 365 *  29.5],
-    [:uranus,   400, 15, 365 *    84],
-    [:neptune,  440, 15, 365 * 164.8],
-    [:pluto,    480,  5, 365 * 247.8],
-  ].map do |name, distance, size, year_in_days|
-    args.state.new_entity(name) do |p|
-      p.path = "sprites/#{name}.png"
-      p.distance = distance * 0.7
-      p.s = size * 0.7
-      p.year_in_days = year_in_days
+  def calc_buttons_frame_selection
+    state.buttons_frame_selection.items = animation_frames.length.map_with_index do |i|
+      { x: state.buttons_frame_selection.left + i * state.buttons_frame_selection.size,
+        y: state.buttons_frame_selection.top - state.buttons_frame_selection.size,
+        inner_rect: {
+          x: (state.buttons_frame_selection.left + 2) + i * state.buttons_frame_selection.size,
+          y: (state.buttons_frame_selection.top - state.buttons_frame_selection.size + 2),
+          w: 16,
+          h: 16,
+        },
+        w: state.buttons_frame_selection.size,
+        h: state.buttons_frame_selection.size,
+        index: i }
     end
   end
 
-  args.state.ship ||= args.state.new_entity(:ship) do |s|
-    s.x = 1280 * rand
-    s.y = 720 * rand
-    s.angle = 0
+  def calc_animation_frames
+    animation_frames.each_with_index do |animation_frame, i|
+      animation_frame[:index] = i
+      animation_frame[:rt_name] = "animation_frame_#{i}"
+    end
   end
-end
 
-def to_sprite args, entity
-  x = 0
-  y = 0
+  def process_queue_create_sprite
+    sprites_to_create = queues.create_sprite
+                              .find_all { |h| h[:at].elapsed? }
 
-  if entity.year_in_days
-    day = args.state.tick_count
-    day_in_year = day % entity.year_in_days
-    entity.random_start_day ||= day_in_year * rand
-    percentage_of_year = day_in_year.fdiv(entity.year_in_days)
-    angle = 365 * percentage_of_year
-    x = angle.vector_x(entity.distance)
-    y = angle.vector_y(entity.distance)
+    queues.create_sprite = queues.create_sprite - sprites_to_create
+
+    sprites_to_create.each do |h|
+      export_animation_frame h[:index], h[:path_override]
+    end
+  end
+
+  def process_queue_reset_sprite
+    sprites_to_reset = queues.reset_sprite
+                             .find_all { |h| h[:at].elapsed? }
+
+    queues.reset_sprite -= sprites_to_reset
+
+    sprites_to_reset.each { |h| gtk.reset_sprite (sprite_path h[:index]) }
   end
 
-  [640 + x - entity.s.half, 360 + y - entity.s.half, entity.s, entity.s, entity.path]
-end
+  def process_queue_update_rt_animation_frame
+    animation_frames_to_update = queues.update_rt_animation_frame
+                                       .find_all { |h| h[:at].elapsed? }
 
-def render args
-  args.outputs.solids << [0, 0, 1280, 720]
+    queues.update_rt_animation_frame -= animation_frames_to_update
 
-  args.outputs.sprites << args.state.stars.map do |x, y, _, r, g, b|
-    [x, y, 10, 10, 'sprites/star.png', 0, 100, r, g, b]
+    animation_frames_to_update.each do |h|
+      update_animation_frame_render_target animation_frames[h[:index]]
+
+      if h[:queue_sprite_creation]
+        queues.create_sprite << { index: h[:index],
+                                  at: state.tick_count + 1 }
+      end
+    end
   end
 
-  args.outputs.sprites << to_sprite(args, args.state.sun)
-  args.outputs.sprites << args.state.planets.map { |p| to_sprite args, p }
-  args.outputs.sprites << [args.state.ship.x, args.state.ship.y, 20, 20, 'sprites/ship.png', args.state.ship.angle]
-end
+  def update_animation_frame_render_target animation_frame
+    return if !animation_frame
 
-def calc args
-  args.state.stars = args.state.stars.map do |x, y, speed, r, g, b|
-    x += speed
-    y += speed
-    x = 0 if x > 1280
-    y = 0 if y > 720
-    [x, y, speed, r, g, b]
+    outputs[animation_frame[:rt_name]].width   = state.rt_canvas.size
+    outputs[animation_frame[:rt_name]].height  = state.rt_canvas.size
+    outputs[animation_frame[:rt_name]].solids << animation_frame[:pixels].map do |f|
+      { x: f.x,
+        y: f.y,
+        w: 1,
+        h: 1, r: 255, g: 255, b: 255 }
+    end
   end
 
-  if args.state.tick_count == 0
-    args.outputs.sounds << 'sounds/bg.ogg'
+  def animation_frames
+    state.animation_frames
   end
-end
 
-def process_inputs args
-  if args.inputs.keyboard.left || args.inputs.controller_one.key_held.left
-    args.state.ship.angle += 1
-  elsif args.inputs.keyboard.right || args.inputs.controller_one.key_held.right
-    args.state.ship.angle -= 1
+  def add_animation_frame_to_end
+    animation_frames << {
+      index: animation_frames.length,
+      pixels: [],
+      rt_name: "animation_frame_#{animation_frames.length}"
+    }
+
+    state.animation_frames_selected_index = (animation_frames.length - 1)
+    queues.update_rt_animation_frame << { index: state.animation_frames_selected_index,
+                                          at: state.tick_count,
+                                          queue_sprite_creation: true }
   end
 
-  if args.inputs.keyboard.up || args.inputs.controller_one.key_held.a
-    args.state.ship.x += args.state.ship.angle.x_vector
-    args.state.ship.y += args.state.ship.angle.y_vector
+  def sprite_path i
+    "canvas/sprite-#{i}.png"
   end
-end
 
-def tick args
-  defaults args
-  render args
-  calc args
-  process_inputs args
-end
+  def export_animation_frame i, path_override = nil
+    return if !state.animation_frames[i]
 
-def r
-  $gtk.reset
-end
+    outputs.screenshots << state.buttons_frame_selection
+                                .items[i][:inner_rect]
+                                .merge(path: path_override || (sprite_path i))
 
-
-Crafting - Craft Game Starting Point - main.rb
-# ./samples/99_genre_crafting/craft_game_starting_point/app/main.rb
-# ==================================================
-# A NOTE TO JAM CRAFT PARTICIPANTS:
-# The comments and code in here are just as small piece of DragonRuby's capabilities.
-# Be sure to check out the rest of the sample apps. Start with README.txt and go from there!
-# ==================================================
+    outputs.screenshots << state.buttons_frame_selection
+                                .items[i][:inner_rect]
+                                .merge(path: "tmp/sprite_backups/#{Time.now.to_i}-sprite-#{i}.png")
 
-# def tick args is the entry point into your game. This function is called at
-# a fixed update time of 60hz (60 fps).
-def tick args
-  # The defaults function intitializes the game.
-  defaults args
+    queues.reset_sprite << { index: i, at: state.tick_count }
+  end
 
-  # After the game is initialized, render it.
-  render args
+  def selected_animation_frame
+    state.animation_frames[state.animation_frames_selected_index]
+  end
 
-  # After rendering the player should be able to respond to input.
-  input args
+  def edit_current_animation_frame point
+    draw_area_point = (to_draw_area point)
+    if state.edit_mode == :drawing && (!selected_animation_frame[:pixels].include? draw_area_point)
+      selected_animation_frame[:pixels] << draw_area_point
+      queues.update_rt_animation_frame << { index: state.animation_frames_selected_index,
+                                            at: state.tick_count,
+                                            queue_sprite_creation: !user_is_editing? }
+    elsif state.edit_mode == :erasing && (selected_animation_frame[:pixels].include? draw_area_point)
+      selected_animation_frame[:pixels] = selected_animation_frame[:pixels].reject { |p| p == draw_area_point }
+      queues.update_rt_animation_frame << { index: state.animation_frames_selected_index,
+                                            at: state.tick_count,
+                                            queue_sprite_creation: !user_is_editing? }
+    end
+  end
 
-  # After responding to input, the game performs any additional calculations.
-  calc args
-end
+  def user_is_editing?
+    state.last_mouse_down > state.last_mouse_up
+  end
 
-def defaults args
-  # hide the mouse cursor for this game, we are going to render our own cursor
-  if args.state.tick_count == 0
-    args.gtk.hide_cursor
+  def to_draw_area point
+    x, y = point
+    x -= rt_canvas.sprite.x
+    y -= rt_canvas.sprite.y
+    { x: x.idiv(rt_canvas.zoom),
+      y: y.idiv(rt_canvas.zoom) }
   end
 
-  args.state.click_ripples ||= []
+  def rt_canvas
+    state.rt_canvas ||= state.new_entity(:rt_canvas)
+  end
 
-  # everything is on a 1280x720 virtual canvas, so you can
-  # hardcode locations
+  def queues
+    state.queues ||= state.new_entity(:queues)
+  end
+end
 
-  # define the borders for where the inventory is located
-  # args.state is a data structure that accepts any arbitrary parameters
-  # so you can create an object graph without having to create any classes.
+$game = OneBitLowrezPaint.new
 
-  # Bottom left is 0, 0. Top right is 1280, 720.
-  # The inventory area is at the top of the screen
-  # the number 80 is the size of all the sprites, so that is what is being
-  # used to decide the with and height
-  args.state.sprite_size = 80
+def tick args
+  $game.args = args
+  $game.tick
+end
 
-  args.state.inventory_border.w  = args.state.sprite_size * 10
-  args.state.inventory_border.h  = args.state.sprite_size * 3
-  args.state.inventory_border.x  = 10
-  args.state.inventory_border.y  = 710 - args.state.inventory_border.h
+# $gtk.reset
 
-  # define the borders for where the crafting area is located
-  # the crafting area is below the inventory area
-  # the number 80 is the size of all the sprites, so that is what is being
-  # used to decide the with and height
-  args.state.craft_border.x =  10
-  args.state.craft_border.y = 220
-  args.state.craft_border.w = args.state.sprite_size * 3
-  args.state.craft_border.h = args.state.sprite_size * 3
+
+Dev Tools - Tile Editor Starting Point - main.rb
+# ./samples/99_genre_dev_tools/tile_editor_starting_point/app/main.rb
+=begin
 
-  # define the area where results are located
-  # the crafting result is to the right of the craft area
-  args.state.result_border.x =  10 + args.state.sprite_size * 3 + args.state.sprite_size
-  args.state.result_border.y = 220 + args.state.sprite_size
-  args.state.result_border.w = args.state.sprite_size
-  args.state.result_border.h = args.state.sprite_size
+ APIs listing that haven't been encountered in previous sample apps:
 
-  # initialize items for the first time if they are nil
-  # you start with 15 wood, 1 chest, and 5 plank
-  # Ruby has built in syntax for dictionaries (they look a lot like json objects).
-  # Ruby also has a special type called a Symbol denoted with a : followed by a word.
-  # Symbols are nice because they remove the need for magic strings.
-  if !args.state.items
-    args.state.items = [
-      {
-        id: :wood, # :wood is a Symbol, this is better than using "wood" for the id
-        quantity: 15,
-        path: 'sprites/wood.png',
-        location: :inventory,
-        ordinal_x: 0, ordinal_y: 0
-      },
-      {
-        id: :chest,
-        quantity: 1,
-        path: 'sprites/chest.png',
-        location: :inventory,
-        ordinal_x: 1, ordinal_y: 0
-      },
-      {
-        id: :plank,
-        quantity: 5,
-        path: 'sprites/plank.png',
-        location: :inventory,
-        ordinal_x: 2, ordinal_y: 0
-      },
-    ]
+ - to_s: Returns a string representation of an object.
+   For example, if we had
+   500.to_s
+   the string "500" would be returned.
+   Similar to to_i, which returns an integer representation of an object.
 
-    # after initializing the oridinal positions, derive the pixel
-    # locations assuming that the width and height are 80
-    args.state.items.each { |item| set_inventory_position args, item }
-  end
+ - Ceil: Returns an integer number greater than or equal to the original
+   with no decimal.
 
-  # define all the oridinal positions of the inventory slots
-  if !args.state.inventory_area
-    args.state.inventory_area = [
-      { ordinal_x: 0,  ordinal_y: 0 },
-      { ordinal_x: 1,  ordinal_y: 0 },
-      { ordinal_x: 2,  ordinal_y: 0 },
-      { ordinal_x: 3,  ordinal_y: 0 },
-      { ordinal_x: 4,  ordinal_y: 0 },
-      { ordinal_x: 5,  ordinal_y: 0 },
-      { ordinal_x: 6,  ordinal_y: 0 },
-      { ordinal_x: 7,  ordinal_y: 0 },
-      { ordinal_x: 8,  ordinal_y: 0 },
-      { ordinal_x: 9,  ordinal_y: 0 },
-      { ordinal_x: 0,  ordinal_y: 1 },
-      { ordinal_x: 1,  ordinal_y: 1 },
-      { ordinal_x: 2,  ordinal_y: 1 },
-      { ordinal_x: 3,  ordinal_y: 1 },
-      { ordinal_x: 4,  ordinal_y: 1 },
-      { ordinal_x: 5,  ordinal_y: 1 },
-      { ordinal_x: 6,  ordinal_y: 1 },
-      { ordinal_x: 7,  ordinal_y: 1 },
-      { ordinal_x: 8,  ordinal_y: 1 },
-      { ordinal_x: 9,  ordinal_y: 1 },
-      { ordinal_x: 0,  ordinal_y: 2 },
-      { ordinal_x: 1,  ordinal_y: 2 },
-      { ordinal_x: 2,  ordinal_y: 2 },
-      { ordinal_x: 3,  ordinal_y: 2 },
-      { ordinal_x: 4,  ordinal_y: 2 },
-      { ordinal_x: 5,  ordinal_y: 2 },
-      { ordinal_x: 6,  ordinal_y: 2 },
-      { ordinal_x: 7,  ordinal_y: 2 },
-      { ordinal_x: 8,  ordinal_y: 2 },
-      { ordinal_x: 9,  ordinal_y: 2 },
-    ]
+ Reminders:
+
+ - ARRAY#inside_rect?: Returns true or false depending on if the point is inside a rect.
 
-    # after initializing the oridinal positions, derive the pixel
-    # locations assuming that the width and height are 80
-    args.state.inventory_area.each { |i| set_inventory_position args, i }
+ - args.outputs.labels: An array. The values generate a label.
+   The parameters are [X, Y, TEXT, SIZE, ALIGNMENT, RED, GREEN, BLUE, ALPHA, FONT STYLE]
+   For more information about labels, go to mygame/documentation/02-labels.md.
 
-    # if you want to see the result you can use the Ruby function called "puts".
-    # Uncomment this line to see the value.
-    # puts args.state.inventory_area
+ - args.outputs.sprites: An array. The values generate a sprite.
+   The parameters are [X, Y, WIDTH, HEIGHT, IMAGE PATH]
+   For more information about sprites, go to mygame/documentation/05-sprites.md.
 
-    # You can see all things written via puts in DragonRuby's Console, or under logs/log.txt.
-    # To bring up DragonRuby's Console, press the ~ key within the game.
-  end
+ - args.outputs.solids: An array. The values generate a solid.
+   The parameters are [X, Y, WIDTH, HEIGHT, RED, GREEN, BLUE]
+   For more information about solids, go to mygame/documentation/03-solids-and-borders.md.
 
-  # define all the oridinal positions of the craft slots
-  if !args.state.craft_area
-    args.state.craft_area = [
-      { ordinal_x: 0, ordinal_y: 0 },
-      { ordinal_x: 0, ordinal_y: 1 },
-      { ordinal_x: 0, ordinal_y: 2 },
-      { ordinal_x: 1, ordinal_y: 0 },
-      { ordinal_x: 1, ordinal_y: 1 },
-      { ordinal_x: 1, ordinal_y: 2 },
-      { ordinal_x: 2, ordinal_y: 0 },
-      { ordinal_x: 2, ordinal_y: 1 },
-      { ordinal_x: 2, ordinal_y: 2 },
-    ]
+ - args.outputs.lines: An array. The values generate a line.
+   The parameters are [X1, Y1, X2, Y2, RED, GREEN, BLUE]
+   For more information about lines, go to mygame/documentation/04-lines.md.
 
-    # after initializing the oridinal positions, derive the pixel
-    # locations assuming that the width and height are 80
-    args.state.craft_area.each { |c| set_craft_position args, c }
-  end
-end
+ - args.state.new_entity: Used when we want to create a new object, like a sprite or button.
+   In this sample app, new_entity is used to create a new button that clears the grid.
+   (Remember, you can use state to define ANY property and it will be retained across frames.)
 
+=end
 
-def render args
-  # for the results area, create a sprite that show its boundaries
-  args.outputs.primitives << { x: args.state.result_border.x,
-                               y: args.state.result_border.y,
-                               w: args.state.result_border.w,
-                               h: args.state.result_border.h,
-                               path: 'sprites/border-black.png' }
+# This sample app shows an empty grid that the user can paint in. There are different image tiles that
+# the user can use to fill the grid, and the "Clear" button can be pressed to clear the grid boxes.
 
-  # for each inventory spot, create a sprite
-  # args.outputs.primitives is how DragonRuby performs a render.
-  # Adding a single hash or multiple hashes to this array will tell
-  # DragonRuby to render those primitives on that frame.
+class TileEditor
+  attr_accessor :inputs, :state, :outputs, :grid, :args
 
-  # The .map function on Array is used instead of any kind of looping.
-  # .map returns a new object for every object within an Array.
-  args.outputs.primitives << args.state.inventory_area.map do |a|
-    { x: a.x, y: a.y, w: a.w, h: a.h, path: 'sprites/border-black.png' }
+  # Runs all the methods necessary for the game to function properly.
+  def tick
+    defaults
+    render
+    check_click
+    draw_buttons
   end
 
-  # for each craft spot, create a sprite
-  args.outputs.primitives << args.state.craft_area.map do |a|
-    { x: a.x, y: a.y, w: a.w, h: a.h, path: 'sprites/border-black.png' }
+  # Sets default values
+  # Initialization only happens in the first frame
+  # NOTE: The values of some of these variables may seem confusingly large at first.
+  # The gridSize is 1600 but it seems a lot smaller on the screen, for example.
+  # But keep in mind that by using the "W", "A", "S", and "D" keys, you can
+  # move the grid's view in all four directions for more grid spaces.
+  def defaults
+    state.tileCords      ||= []
+    state.tileQuantity   ||= 6
+    state.tileSize       ||= 50
+    state.tileSelected   ||= 1
+    state.tempX          ||= 50
+    state.tempY          ||= 500
+    state.speed          ||= 4
+    state.centerX        ||= 4000
+    state.centerY        ||= 4000
+    state.originalCenter ||= [state.centerX, state.centerY]
+    state.gridSize       ||= 1600
+    state.lineQuantity   ||= 50
+    state.increment      ||= state.gridSize / state.lineQuantity
+    state.gridX          ||= []
+    state.gridY          ||= []
+    state.filled_squares ||= []
+    state.grid_border    ||= [390, 140, 500, 500]
+
+    get_grid unless state.tempX == 0 # calls get_grid in the first frame only
+    determineTileCords unless state.tempX == 0 # calls determineTileCords in first frame
+    state.tempX = 0 # sets tempX to 0; the two methods aren't called again
   end
 
-  # after the borders have been rendered, render the
-  # items within those slots (and allow for highlighting)
-  # if an item isn't currently being held
-  allow_inventory_highlighting = !args.state.held_item
+  # Calculates the placement of lines or separators in the grid
+  def get_grid
+    curr_x = state.centerX - (state.gridSize / 2) # starts at left of grid
+    deltaX = state.gridSize / state.lineQuantity # finds distance to place vertical lines evenly through width of grid
+    (state.lineQuantity + 2).times do
+      state.gridX << curr_x # adds curr_x to gridX collection
+      curr_x += deltaX # increment curr_x by the distance between vertical lines
+    end
 
-  # go through each item and render them
-  # use Array's find_all method to remove any items that are currently being held
-  args.state.items.find_all { |item| item[:location] != :held }.map do |item|
-    # if an item is currently being held, don't render it in it's spot within the
-    # inventory or craft area (this is handled via the find_all method).
+    curr_y = state.centerY - (state.gridSize / 2) # starts at bottom of grid
+    deltaY = state.gridSize / state.lineQuantity # finds distance to place horizontal lines evenly through height of grid
+    (state.lineQuantity + 2).times do
+      state.gridY << curr_y # adds curr_y to gridY collection
+      curr_y += deltaY # increments curr_y to distance between horizontal lines
+    end
+  end
 
-    # the item_prefab returns a hash containing all the visual components of an item.
-    # the main sprite, the black background, the quantity text, and a hover indication
-    # if the mouse is currently hovering over the item.
-    args.outputs.primitives << item_prefab(args, item, allow_inventory_highlighting, args.inputs.mouse)
+  # Determines coordinate positions of patterned tiles (on the left side of the grid)
+  def determineTileCords
+    state.tempCounter ||= 1 # initializes tempCounter to 1
+    state.tileQuantity.times do # there are 6 different kinds of tiles
+      state.tileCords += [[state.tempX, state.tempY, state.tempCounter]] # adds tile definition to collection
+      state.tempX += 75 # increments tempX to put horizontal space between the patterned tiles
+      state.tempCounter += 1 # increments tempCounter
+      if state.tempX > 200 # if tempX exceeds 200 pixels
+        state.tempX = 50 # a new row of patterned tiles begins
+        state.tempY -= 75 # the new row is 75 pixels lower than the previous row
+      end
+    end
   end
 
-  # The last thing we want to render is the item currently being held.
-  args.outputs.primitives << item_prefab(args, args.state.held_item, allow_inventory_highlighting, args.inputs.mouse)
+  # Outputs objects (grid, tiles, etc) onto the screen
+  def render
+    outputs.sprites << state.tileCords.map do # outputs tileCords collection using images in sprites folder
+      |x, y, order|
+      [x, y, state.tileSize, state.tileSize, 'sprites/image' + order.to_s + ".png"]
+    end
+    outputs.solids << [0, 0, 1280, 720, 255, 255, 255] # outputs white background
+    add_grid # outputs grid
+    print_title # outputs title and current tile pattern
+  end
 
-  args.outputs.primitives << args.state.click_ripples
+  # Creates a grid by outputting vertical and horizontal grid lines onto the screen.
+  # Outputs sprites for the filled_squares collection onto the screen.
+  def add_grid
 
-  # render a mouse cursor since we have the OS cursor hidden
-  args.outputs.primitives << { x: args.inputs.mouse.x - 5, y: args.inputs.mouse.y - 5, w: 10, h: 10, path: 'sprites/circle-gray.png', a: 128 }
-end
+    # Outputs the grid's border.
+    outputs.borders << state.grid_border
+    temp = 0
 
-# Alrighty! This is where all the fun happens
-def input args
-  # if the mouse is clicked and not item is currently being held
-  # args.state.held_item is nil when the game starts.
-  # If the player clicks, the property args.inputs.mouse.click will
-  # be a non nil value, we don't want to process any of the code here
-  # if the mouse hasn't been clicked
-  return if !args.inputs.mouse.click
+    # Before looking at the code that outputs the vertical and horizontal lines in the
+    # grid, take note of the fact that:
+    # grid_border[1] refers to the border's bottom line (running horizontally),
+    # grid_border[2] refers to the border's top line (running (horizontally),
+    # grid_border[0] refers to the border's left line (running vertically),
+    # and grid_border[3] refers to the border's right line (running vertically).
 
-  # if a click occurred, add a ripple to the ripple queue
-  args.state.click_ripples << { x: args.inputs.mouse.x - 5, y: args.inputs.mouse.y - 5, w: 10, h: 10, path: 'sprites/circle-gray.png', a: 128 }
+    #           [2]
+    #       ----------
+    #       |        |
+    # [0]   |        | [3]
+    #       |        |
+    #       ----------
+    #           [1]
 
-  # if the mouse has been clicked, and no item is currently held...
-  if !args.state.held_item
-    # see if any of the items intersect the pointer using the inside_rect? method
-    # the find method will either return the first object that returns true
-    # for the match clause, or it'll return nil if nothing matches the match clause
-    found = args.state.items.find do |item|
-      # for each item in args.state.items, run the following boolean check
-      args.inputs.mouse.click.point.inside_rect?(item)
+    # Calculates the positions and outputs the x grid lines in the color gray.
+    state.gridX.map do # perform an action on all elements of the gridX collection
+      |x|
+      temp += 1 # increment temp
+
+      # if x's value is greater than (or equal to) the x value of the border's left side
+      # and less than (or equal to) the x value of the border's right side
+      if x >= state.centerX - (state.grid_border[2] / 2) && x <= state.centerX + (state.grid_border[2] / 2)
+        delta = state.centerX - 640
+        # vertical lines have the same starting and ending x positions
+        # starting y and ending y positions lead from the bottom of the border to the top of the border
+        outputs.lines << [x - delta, state.grid_border[1], x - delta, state.grid_border[1] + state.grid_border[2], 150, 150, 150] # sets definition of vertical line and outputs it
+      end
     end
+    temp = 0
 
-    # if an item intersects the mouse pointer, then set the item's location to :held and
-    # set args.state.held_item to the item for later reference
-    if found
-      args.state.held_item = found
-      found[:location] = :held
+    # Calculates the positions and outputs the y grid lines in the color gray.
+    state.gridY.map do # perform an action on all elements of the gridY collection
+      |y|
+      temp += 1 # increment temp
+
+      # if y's value is greater than (or equal to) the y value of the border's bottom side
+      # and less than (or equal to) the y value of the border's top side
+      if y >= state.centerY - (state.grid_border[3] / 2) && y <= state.centerY + (state.grid_border[3] / 2)
+        delta = state.centerY - 393
+        # horizontal lines have the same starting and ending y positions
+        # starting x and ending x positions lead from the left side of the border to the right side of the border
+        outputs.lines << [state.grid_border[0], y - delta, state.grid_border[0] + state.grid_border[3], y - delta, 150, 150, 150] # sets definition of horizontal line and outputs it
+      end
     end
 
-  # if the mouse is clicked and an item is currently beign held....
-  elsif args.state.held_item
-    # determine if a slot within the craft area was clicked
-    craft_area = args.state.craft_area.find { |a| args.inputs.mouse.click.point.inside_rect? a }
+    # Sets values and outputs sprites for the filled_squares collection.
+    state.filled_squares.map do # perform an action on every element of the filled_squares collection
+      |x, y, w, h, sprite|
+        # if x's value is greater than (or equal to) the x value of 17 pixels to the left of the border's left side
+        # and less than (or equal to) the x value of the border's right side
+        # and y's value is greater than (or equal to) the y value of the border's bottom side
+        # and less than (or equal to) the y value of 25 pixels above the border's top side
+        # NOTE: The allowance of 17 pixels and 25 pixels is due to the fact that a grid box may be slightly cut off or
+        # not entirely visible in the grid's view (until it is moved using "W", "A", "S", "D")
+        if x >= state.centerX - (state.grid_border[2] / 2) - 17 && x <= state.centerX + (state.grid_border[2] / 2) &&
+           y >= state.centerY - (state.grid_border[3] / 2) && y <= state.centerY + (state.grid_border[3] / 2) + 25
+          # calculations done to place sprites in grid spaces that are meant to filled in
+          # mess around with the x and y values and see how the sprite placement changes
+          outputs.sprites << [x - state.centerX + 630, y - state.centerY + 360, w, h, sprite]
+        end
+      end
+
+      # outputs a white solid along the left side of the grid (change the color and you'll be able to see it against the white background)
+      # state.increment subtracted in x parameter because solid's position is denoted by bottom left corner
+      # state.increment subtracted in y parameter to avoid covering the title label
+      outputs.primitives << [state.grid_border[0] - state.increment,
+                             state.grid_border[1] - state.increment, state.increment, state.grid_border[3] + (state.increment * 2),
+                             255, 255, 255].solid
+
+      # outputs a white solid along the right side of the grid
+      # state.increment subtracted from y parameter to avoid covering title label
+      outputs.primitives << [state.grid_border[0] + state.grid_border[2],
+                             state.grid_border[1] - state.increment, state.increment, state.grid_border[3] + (state.increment * 2),
+                             255, 255, 255].solid
 
-    # also determine if a slot within the inventory area was clicked
-    inventory_area = args.state.inventory_area.find { |a| args.inputs.mouse.click.point.inside_rect? a }
+      # outputs a white solid along the bottom of the grid
+      # state.increment subtracted from y parameter to avoid covering last row of grid boxes
+      outputs.primitives << [state.grid_border[0] - state.increment, state.grid_border[1] - state.increment,
+                             state.grid_border[2] + (2 * state.increment), state.increment, 255, 255, 255].solid
 
-    # if the click was within a craft area
-    if craft_area
-      # check to see if an item is already there and ignore the click if an item is found
-      # item_at_craft_slot is a helper method that returns an item or nil for a given oridinal
-      # position
-      item_already_there = item_at_craft_slot args, craft_area[:ordinal_x], craft_area[:ordinal_y]
+      # outputs a white solid along the top of the grid
+      outputs.primitives << [state.grid_border[0] - state.increment, state.grid_border[1] + state.grid_border[3],
+                             state.grid_border[2] + (2 * state.increment), state.increment, 255, 255, 255].solid
 
-      # if an item *doesn't* exist in the craft area
-      if !item_already_there
-        # if the quantity they are currently holding is greater than 1
-        if args.state.held_item[:quantity] > 1
-          # remove one item (creating a seperate item of the same type), and place it
-          # at the oridinal position and location of the craft area
-          # the .merge method on Hash creates a new Hash, but updates any values
-          # passed as arguments to merge
-          new_item = args.state.held_item.merge(quantity: 1,
-                                                location: :craft,
-                                                ordinal_x: craft_area[:ordinal_x],
-                                                ordinal_y: craft_area[:ordinal_y])
+  end
 
-          # after the item is crated, place it into the args.state.items collection
-          args.state.items << new_item
+  # Outputs title and current tile pattern
+  def print_title
+    outputs.labels << [640, 700, 'Mouse to Place Tile, WASD to Move Around', 7, 1] # title label
+    outputs.lines << horizontal_separator(660, 0, 1280) # outputs horizontal separator
+    outputs.labels << [1050, 500, 'Current:', 3, 1] # outputs Current label
+    outputs.sprites << [1110, 474, state.tileSize / 2, state.tileSize / 2, 'sprites/image' + state.tileSelected.to_s + ".png"] # outputs sprite of current tile pattern using images in sprites folder; output is half the size of a tile
+  end
 
-          # then subtract one from the held item
-          args.state.held_item[:quantity] -= 1
+  # Sets the starting position, ending position, and color for the horizontal separator.
+  def horizontal_separator y, x, x2
+    [x, y, x2, y, 150, 150, 150] # definition of separator; horizontal line means same starting/ending y
+  end
 
-        # if the craft area is available and there is only one item being held
-        elsif args.state.held_item[:quantity] == 1
-          # instead of creating any new items just set the location of the held item
-          # to the oridinal position of the craft area, and then nil out the
-          # held item state so that a new item can be picked up
-          args.state.held_item[:location] = :craft
-          args.state.held_item[:ordinal_x] = craft_area[:ordinal_x]
-          args.state.held_item[:ordinal_y] = craft_area[:ordinal_y]
-          args.state.held_item = nil
+  # Checks if the mouse is being clicked or dragged
+  def check_click
+    if inputs.keyboard.key_down.r # if the "r" key is pressed down
+      $dragon.reset
+    end
+
+    if inputs.mouse.down #is mouse up or down?
+      state.mouse_held = true
+      if inputs.mouse.position.x < state.grid_border[0] # if mouse's x position is inside the grid's borders
+        state.tileCords.map do # perform action on all elements of tileCords collection
+          |x, y, order|
+          # if mouse's x position is greater than (or equal to) the starting x position of a tile
+          # and the mouse's x position is also less than (or equal to) the ending x position of that tile,
+          # and the mouse's y position is greater than (or equal to) the starting y position of that tile,
+          # and the mouse's y position is also less than (or equal to) the ending y position of that tile,
+          # (BASICALLY, IF THE MOUSE'S POSITION IS WITHIN THE STARTING AND ENDING POSITIONS OF A TILE)
+          if inputs.mouse.position.x >= x && inputs.mouse.position.x <= x + state.tileSize &&
+             inputs.mouse.position.y >= y && inputs.mouse.position.y <= y + state.tileSize
+            state.tileSelected = order # that tile is selected
+          end
         end
       end
+    elsif inputs.mouse.up # otherwise, if the mouse is in the "up" state
+      state.mouse_held = false # mouse is not held down or dragged
+      state.mouse_dragging = false
+    end
 
-    # if the selected area is an inventory area (as opposed to within the craft area)
-    elsif inventory_area
+    if state.mouse_held &&    # mouse needs to be down
+       !inputs.mouse.click &&     # must not be first click
+       ((inputs.mouse.previous_click.point.x - inputs.mouse.position.x).abs > 15 ||
+        (inputs.mouse.previous_click.point.y - inputs.mouse.position.y).abs > 15) # Need to move 15 pixels before "drag"
+      state.mouse_dragging = true
+    end
 
-      # check to see if there is already an item in that inventory slot
-      # the item_at_inventory_slot helper method returns an item or nil
-      item_already_there = item_at_inventory_slot args, inventory_area[:ordinal_x], inventory_area[:ordinal_y]
+    # if mouse is clicked inside grid's border, search_lines method is called with click input type
+    if ((inputs.mouse.click) && (inputs.mouse.click.point.inside_rect? state.grid_border))
+      search_lines(inputs.mouse.click.point, :click)
 
-      # if there is already an item there, and the item types/id match
-      if item_already_there && item_already_there[:id] == args.state.held_item[:id]
-        # then merge the item quantities
-        held_quantity = args.state.held_item[:quantity]
-        item_already_there[:quantity] += held_quantity
+    # if mouse is dragged inside grid's border, search_lines method is called with drag input type
+    elsif ((state.mouse_dragging) && (inputs.mouse.position.inside_rect? state.grid_border))
+      search_lines(inputs.mouse.position, :drag)
+    end
 
-        # remove the item being held from the items collection (since it's quantity is now 0)
-        args.state.items.reject! { |i| i[:location] == :held }
+    # Changes grid's position on screen by moving it up, down, left, or right.
 
-        # nil out the held_item so a new item can be picked up
-        args.state.held_item = nil
+    # centerX is incremented by speed if the "d" key is pressed and if that sum is less than
+    # the original left side of the center plus half the grid, minus half the top border of grid.
+    # MOVES GRID RIGHT (increasing x)
+    state.centerX += state.speed if inputs.keyboard.key_held.d &&
+                                    (state.centerX + state.speed) < state.originalCenter[0] + (state.gridSize / 2) - (state.grid_border[2] / 2)
+    # centerX is decremented by speed if the "a" key is pressed and if that difference is greater than
+    # the original left side of the center minus half the grid, plus half the top border of grid.
+    # MOVES GRID LEFT (decreasing x)
+    state.centerX -= state.speed if inputs.keyboard.key_held.a &&
+                                    (state.centerX - state.speed) > state.originalCenter[0] - (state.gridSize / 2) + (state.grid_border[2] / 2)
+    # centerY is incremented by speed if the "w" key is pressed and if that sum is less than
+    # the original bottom of the center plus half the grid, minus half the right border of grid.
+    # MOVES GRID UP (increasing y)
+    state.centerY += state.speed if inputs.keyboard.key_held.w &&
+                                    (state.centerY + state.speed) < state.originalCenter[1] + (state.gridSize / 2) - (state.grid_border[3] / 2)
+    # centerY is decremented by speed if the "s" key is pressed and if the difference is greater than
+    # the original bottom of the center minus half the grid, plus half the right border of grid.
+    # MOVES GRID DOWN (decreasing y)
+    state.centerY -= state.speed if inputs.keyboard.key_held.s &&
+                                    (state.centerY - state.speed) > state.originalCenter[1] - (state.gridSize / 2) + (state.grid_border[3] / 2)
+  end
 
-      # if there currently isn't an item there, then put the held item in the slot
-      elsif !item_already_there
-        args.state.held_item[:location] = :inventory
-        args.state.held_item[:ordinal_x] = inventory_area[:ordinal_x]
-        args.state.held_item[:ordinal_y] = inventory_area[:ordinal_y]
+  # Performs calculations on the gridX and gridY collections, and sets values.
+  # Sets the definition of a grid box, including the image that it is filled with.
+  def search_lines (point, input_type)
+    point.x += state.centerX - 630 # increments x and y
+    point.y += state.centerY - 360
+    findX = 0
+    findY = 0
+    increment = state.gridSize / state.lineQuantity # divides grid by number of separators
 
-        # nil out the held_item so a new item can be picked up
-        args.state.held_item = nil
-      end
+    state.gridX.map do # perform an action on every element of collection
+      |x|
+      # findX increments x by 10 if point.x is less than that sum and findX is currently 0
+      findX = x + 10 if point.x < (x + 10) && findX == 0
     end
-  end
-end
 
-# the calc method is executed after input
-def calc args
-  # make sure that the real position of the inventory
-  # items are updated every frame to ensure that they
-  # are placed correctly given their location and oridinal positions
-  # instead of using .map, here we use .each (since we are not returning a new item and just updating the items in place)
-  args.state.items.each do |item|
-    # based on the location of the item, invoke the correct pixel conversion method
-    if item[:location] == :inventory
-      set_inventory_position args, item
-    elsif item[:location] == :craft
-      set_craft_position args, item
-    elsif item[:location] == :held
-      # if the item is held, center the item around the mouse pointer
-      args.state.held_item.x = args.inputs.mouse.x - args.state.held_item.w.half
-      args.state.held_item.y = args.inputs.mouse.y - args.state.held_item.h.half
+    state.gridY.map do
+      |y|
+      # findY is set to y if point.y is less than that value and findY is currently 0
+      findY = y if point.y < (y) && findY == 0
     end
-  end
+    # position of a box is denoted by bottom left corner, which is why the increment is being subtracted
+    grid_box = [findX - (increment.ceil), findY - (increment.ceil), increment.ceil, increment.ceil,
+                "sprites/image" + state.tileSelected.to_s + ".png"] # sets sprite definition
 
-  # for each hash/sprite in the click ripples queue,
-  # expand its size by 20 percent and decrease its alpha
-  # by 10.
-  args.state.click_ripples.each do |ripple|
-    delta_w = ripple.w * 1.2 - ripple.w
-    delta_h = ripple.h * 1.2 - ripple.h
-    ripple.x -= delta_w.half
-    ripple.y -= delta_h.half
-    ripple.w += delta_w
-    ripple.h += delta_h
-    ripple.a -= 10
+    if input_type == :click # if user clicks their mouse
+      if state.filled_squares.include? grid_box # if grid box is already filled in
+        state.filled_squares.delete grid_box # box is cleared and removed from filled_squares
+      else
+        state.filled_squares << grid_box # otherwise, box is filled in and added to filled_squares
+      end
+    elsif input_type == :drag # if user drags mouse
+      unless state.filled_squares.include? grid_box # unless grid box dragged over is already filled in
+        state.filled_squares << grid_box # box is filled in and added to filled_squares
+      end
+    end
   end
 
-  # remove any items from the collection where the alpha value is less than equal to
-  # zero using the reject! method (reject with an exclamation point at the end changes the
-  # array value in place, while reject without the exclamation point returns a new array).
-  args.state.click_ripples.reject! { |ripple| ripple.a <= 0 }
-end
+  # Creates a "Clear" button using labels and borders.
+  def draw_buttons
+    x, y, w, h = 390, 50, 240, 50
+    state.clear_button        ||= state.new_entity(:button_with_fade)
 
-# helper function for finding an item at a craft slot
-def item_at_craft_slot args, ordinal_x, ordinal_y
-  args.state.items.find { |i| i[:location] == :craft && i[:ordinal_x] == ordinal_x && i[:ordinal_y] == ordinal_y }
-end
+    # x and y positions are set to display "Clear" label in center of the button
+    # Try changing first two parameters to simply x, y and see what happens to the text placement
+    state.clear_button.label  ||= [x + w.half, y + h.half + 10, "Clear", 0, 1]
+    state.clear_button.border ||= [x, y, w, h] # definition of button's border
 
-# helper function for finding an item at an inventory slot
-def item_at_inventory_slot args, ordinal_x, ordinal_y
-  args.state.items.find { |i| i[:location] == :inventory && i[:ordinal_x] == ordinal_x && i[:ordinal_y] == ordinal_y }
-end
+    # If the mouse is clicked inside the borders of the clear button
+    if inputs.mouse.click && inputs.mouse.click.point.inside_rect?(state.clear_button.border)
+      state.clear_button.clicked_at = inputs.mouse.click.created_at # value is frame of mouse click
+      state.filled_squares.clear # filled squares collection is emptied (squares are cleared)
+      inputs.mouse.previous_click = nil # no previous click
+    end
 
-# helper function that creates a visual representation of an item
-def item_prefab args, item, should_highlight, mouse
-  return nil unless item
+    outputs.labels << state.clear_button.label # outputs clear button
+    outputs.borders << state.clear_button.border
 
-  overlay = nil
+    # When the clear button is clicked, the color of the button changes
+    # and the transparency changes, as well. If you change the time from
+    # 0.25.seconds to 1.25.seconds or more, the change will last longer.
+    if state.clear_button.clicked_at
+      outputs.solids << [x, y, w, h, 0, 180, 80, 255 * state.clear_button.clicked_at.ease(0.25.seconds, :flip)]
+    end
+  end
+end
 
-  x = item.x
-  y = item.y
-  w = item.w
-  h = item.h
+$tile_editor = TileEditor.new
 
-  if should_highlight && mouse.point.inside_rect?(item)
-    overlay = { x: x, y: y, w: w, h: h, path: "sprites/square-blue.png", a: 130, }
+def tick args
+  $tile_editor.inputs = args.inputs
+  $tile_editor.grid = args.grid
+  $tile_editor.args = args
+  $tile_editor.outputs = args.outputs
+  $tile_editor.state = args.state
+  $tile_editor.tick
+  tick_instructions args, "Roll your own tile editor. CLICK to select a sprite. CLICK in grid to place sprite. WASD to move around."
+end
+
+def tick_instructions args, text, y = 715
+  return if args.state.key_event_occurred
+  if args.inputs.mouse.click ||
+     args.inputs.keyboard.directional_vector ||
+     args.inputs.keyboard.key_down.enter ||
+     args.inputs.keyboard.key_down.escape
+    args.state.key_event_occurred = true
   end
 
-  [
-    # sprites are hashes with a path property, this is the main sprite
-    { x: x,      y: y, w: args.state.sprite_size, h: args.state.sprite_size, path: item[:path], },
+  args.outputs.debug << [0, y - 50, 1280, 60].solid
+  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
+  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+end
 
-    # this represents the black area in the bottom right corner of the main sprite so that the
-    # quantity is visible
-    { x: x + 55, y: y, w: 25, h: 25, path: "sprites/square-black.png", }, # sprites are hashes with a path property
+
+Lowrez - Nokia 3310 - main.rb
+# ./samples/99_genre_lowrez/nokia_3310/app/main.rb
+require 'app/nokia.rb'
 
-    # labels are hashes with a text property
-    { x: x + 56, y: y + 22, text: "#{item[:quantity]}", r: 255, g: 255, b: 255, },
+def tick args
+  # =======================================================================
+  # ==== HELLO WORLD ======================================================
+  # =======================================================================
+  # Steps to get started:
+  # 1. ~def tick args~ is the entry point for your game.
+  # 2. There are quite a few code samples below, remove the "##"
+  #    before each line and save the file to see the changes.
+  # 3. 0,  0 is in bottom left and 83, 47 is in top right corner.
+  # 4. Be sure to come to the discord channel if you need
+  #    more help: [[http://discord.dragonruby.org]].
 
-    # this is the mouse overlay, if the overlay isn't applicable, then this value will be nil (nil values will not be rendered)
-    overlay
-  ]
-end
+  # Commenting and uncommenting code:
+  # - Add a "#" infront of lines to comment out code
+  # - Remove the "#" infront of lines to comment out code
 
-# helper function for deriving the position of an item within inventory
-def set_inventory_position args, item
-  item.x = args.state.inventory_border.x + item[:ordinal_x] * 80
-  item.y = (args.state.inventory_border.y + args.state.inventory_border.h - 80) - item[:ordinal_y] * 80
-  item.w = 80
-  item.h = 80
-end
+  # Invoke the hello_world subroutine/method
+  hello_world args # <---- add a "#" to the beginning of the line to stop running this subroutine/method.
 
-# helper function for deriving the position of an item within the craft area
-def set_craft_position args, item
-  item.x = args.state.craft_border.x + item[:ordinal_x] * 80
-  item.y = (args.state.craft_border.y + args.state.inventory_border.h - 80) - item[:ordinal_y] * 80
-  item.w = 80
-  item.h = 80
-end
+  # =======================================================================
+  # ==== HOW TO RENDER A LABEL ============================================
+  # =======================================================================
 
-# Any lines outside of a function will be executed when the file is reloaded.
-# So every time you save main.rb, the game will be reset.
-# Comment out the line below if you don't want this to happen.
-$gtk.reset
+  # Uncomment the line below to invoke the how_to_render_a_label subroutine/method.
+  # Note: The method is defined in this file with the signature ~def how_to_render_a_label args~
+  #       Scroll down to the method to see the details.
 
-

-Dev Tools - Add Buttons To Console - main.rb
-# ./samples/99_genre_dev_tools/add_buttons_to_console/app/main.rb
-# You can customize the buttons that show up in the Console.
-class GTK::Console::Menu
-  # STEP 1: Override the custom_buttons function.
-  def custom_buttons
-    [
-      (button id: :yay,
-              # row for button
-              row: 3,
-              # column for button
-              col: 10,
-              # text
-              text: "I AM CUSTOM",
-              # when clicked call the custom_button_clicked function
-              method: :custom_button_clicked),
+  # Remove the "#" at the beginning of the line below
+  # how_to_render_a_label args # <---- remove the "#" at the beginning of this line to run the method
 
-      (button id: :yay,
-              # row for button
-              row: 3,
-              # column for button
-              col: 9,
-              # text
-              text: "CUSTOM ALSO",
-              # when clicked call the custom_button_also_clicked function
-              method: :custom_button_also_clicked)
-    ]
-  end
 
-  # STEP 2: Define the function that should be called.
-  def custom_button_clicked
-    log "* INFO: I AM CUSTOM was clicked!"
-  end
+  # =======================================================================
+  # ==== HOW TO RENDER A FILLED SQUARE (SOLID) ============================
+  # =======================================================================
+  # Remove the "#" at the beginning of the line below
+  # how_to_render_solids args
 
-  def custom_button_also_clicked
-    log "* INFO: Custom Button Clicked at #{Kernel.global_tick_count}!"
 
-    all_buttons_as_string = $gtk.console.menu.buttons.map do |b|
-      <<-S.strip
-** id: #{b[:id]}
-:PROPERTIES:
-:id:     :#{b[:id]}
-:method: :#{b[:method]}
-:text:   #{b[:text]}
-:END:
-S
-    end.join("\n")
+  # =======================================================================
+  # ==== HOW TO RENDER AN UNFILLED SQUARE (BORDER) ========================
+  # =======================================================================
+  # Remove the "#" at the beginning of the line below
+  # how_to_render_borders args
 
-    log <<-S
-* INFO: Here are all the buttons:
-#{all_buttons_as_string}
-S
-  end
-end
 
-def tick args
-  args.outputs.labels << [args.grid.center.x, args.grid.center.y,
-                          "Open the DragonRuby Console to see the custom menu items.",
-                          0, 1]
-end
+  # =======================================================================
+  # ==== HOW TO RENDER A LINE =============================================
+  # =======================================================================
+  # Remove the "#" at the beginning of the line below
+  # how_to_render_lines args
 
-
-Dev Tools - Animation Creator Starting Point - main.rb
-# ./samples/99_genre_dev_tools/animation_creator_starting_point/app/main.rb
-class OneBitLowrezPaint
-  attr_gtk
 
-  def tick
-    outputs.background_color = [0, 0, 0]
-    defaults
-    render_instructions
-    render_canvas
-    render_buttons_frame_selection
-    render_animation_frame_thumbnails
-    render_animation
-    input_mouse_click
-    input_keyboard
-    calc_auto_export
-    calc_buttons_frame_selection
-    calc_animation_frames
-    process_queue_create_sprite
-    process_queue_reset_sprite
-    process_queue_update_rt_animation_frame
-  end
+  # =======================================================================
+  # == HOW TO RENDER A SPRITE =============================================
+  # =======================================================================
+  # Remove the "#" at the beginning of the line below
+  # how_to_render_sprites args
 
-  def defaults
-    state.animation_frames_per_second = 12
-    queues.create_sprite ||= []
-    queues.reset_sprite ||= []
-    queues.update_rt_animation_frame ||= []
 
-    if !state.animation_frames
-      state.animation_frames ||= []
-      add_animation_frame_to_end
-    end
+  # =======================================================================
+  # ==== HOW TO MOVE A SPRITE BASED OFF OF USER INPUT =====================
+  # =======================================================================
+  # Remove the "#" at the beginning of the line below
+  # how_to_move_a_sprite args
 
-    state.last_mouse_down ||= 0
-    state.last_mouse_up   ||= 0
 
-    state.buttons_frame_selection.left = 10
-    state.buttons_frame_selection.top  = grid.top - 10
-    state.buttons_frame_selection.size = 20
+  # =======================================================================
+  # ==== HOW TO ANIMATE A SPRITE (SEPERATE PNGS) ==========================
+  # =======================================================================
+  # Remove the "#" at the beginning of the line below
+  # how_to_animate_a_sprite args
 
-    defaults_canvas_sprite
 
-    state.edit_mode ||= :drawing
-  end
+  # =======================================================================
+  # ==== HOW TO ANIMATE A SPRITE (SPRITE SHEET) ===========================
+  # =======================================================================
+  # Remove the "#" at the beginning of the line below
+  # how_to_animate_a_sprite_sheet args
 
-  def defaults_canvas_sprite
-    rt_canvas.size   = 16
-    rt_canvas.zoom   = 30
-    rt_canvas.width  = rt_canvas.size * rt_canvas.zoom
-    rt_canvas.height = rt_canvas.size * rt_canvas.zoom
-    rt_canvas.sprite = { x: 0,
-                         y: 0,
-                         w: rt_canvas.width,
-                         h: rt_canvas.height,
-                         path: :rt_canvas }.center_inside_rect(x: 0, y: 0, w: 640, h: 720)
 
-    return unless state.tick_count == 1
+  # =======================================================================
+  # ==== HOW TO DETERMINE COLLISION =============================================
+  # =======================================================================
+  # Remove the "#" at the beginning of the line below
+  # how_to_determine_collision args
 
-    outputs[:rt_canvas].width      = rt_canvas.width
-    outputs[:rt_canvas].height     = rt_canvas.height
-    outputs[:rt_canvas].sprites   << (rt_canvas.size + 1).map_with_index do |x|
-      (rt_canvas.size + 1).map_with_index do |y|
-        path = 'sprites/square-white.png'
-        path = 'sprites/square-blue.png' if x == 7 || x == 8
-        { x: x * rt_canvas.zoom,
-          y: y * rt_canvas.zoom,
-          w: rt_canvas.zoom,
-          h: rt_canvas.zoom,
-          path: path,
-          a: 50 }
-      end
-    end
-  end
 
-  def render_instructions
-    instructions = <<-S
-* Instructions:
-- All data is stored in the ~canvas~ directory.
-- Hold ~d~ to set the edit mode to erase.
-- Release ~d~ to set the edit mode drawing.
-- Press ~a~ to added a frame to the end.
-- Press ~b~ to select the previous frame.
-- Press ~f~ to select the next frame.
-- Press ~c~ to copy a frame.
-- Press ~v~ to paste a copied frame into the selected frame.
-- Press ~x~ to delete the currently selected frame.
-- Press ~w~ to save the canvas and export all sprites.
-- Press ~l~ to load the canvas.
-S
+  # =======================================================================
+  # ==== HOW TO CREATE BUTTONS ==================================================
+  # =======================================================================
+  # Remove the "#" at the beginning of the line below
+  # how_to_create_buttons args
 
-    instructions.strip.each_line.with_index do |l, i|
-      outputs.labels << { x: 840, y: 500 - (i * 20), text: "#{l}",
-                          r: 180, g: 180, b: 180, size_enum: -3 }
-    end
-  end
+  # ==== The line below renders a debug grid, mouse information, and current tick
+  # render_debug args
+end
 
-  def render_canvas
-    return if state.tick_count.zero?
-    outputs.sprites << rt_canvas.sprite
-  end
+# =======================================================================
+# ==== HELLO WORLD ======================================================
+# =======================================================================
+def hello_world args
+  args.nokia.solids  << { x: 0, y: 64, w: 10, h: 10, r: 255 }
 
-  def render_buttons_frame_selection
-    args.outputs.primitives << state.buttons_frame_selection.items.map_with_index do |b, i|
-      label = { x: b.x + state.buttons_frame_selection.size.half,
-                y: b.y,
-                text: "#{i + 1}", r: 180, g: 180, b: 180,
-                size_enum: -4, alignment_enum: 1 }.label
+  args.nokia.labels  << {
+    x: 42,
+    y: 46,
+    text: "nokia 3310 jam 3",
+    size_enum: NOKIA_FONT_SM,
+    alignment_enum: 1,
+    r: 0,
+    g: 0,
+    b: 0,
+    a: 255,
+    font: NOKIA_FONT_PATH
+  }
+
+  args.nokia.sprites << {
+    x: 42 - 10,
+    y: 26 - 10,
+    w: 20,
+    h: 20,
+    path: 'sprites/monochrome-ship.png',
+    a: 255,
+    angle: args.state.tick_count % 360
+  }
+end
+
+# =======================================================================
+# ==== HOW TO RENDER A LABEL ============================================
+# =======================================================================
+def how_to_render_a_label args
+  # NOTE: Text is aligned from the TOP LEFT corner
 
-      selection_border = b.merge(r: 40, g: 40, b: 40).border
+  # Render an EXTRA LARGE/XL label (remove the "#" in front of each line below)
+  args.nokia.labels << { x: 0, y: 46, text: "Hello World",
+                         size_enum: NOKIA_FONT_XL,
+                         r: 0, g: 0, b: 0, a: 255,
+                         font: NOKIA_FONT_PATH }
 
-      if i == state.animation_frames_selected_index
-        selection_border = b.merge(r: 40, g: 230, b: 200).border
-      end
+  # Render a LARGE/LG label (remove the "#" in front of each line below)
+  args.nokia.labels << { x: 0, y: 29, text: "Hello World",
+                          size_enum: NOKIA_FONT_LG,
+                          r: 0, g: 0, b: 0, a: 255,
+                          font: NOKIA_FONT_PATH }
 
-      [selection_border, label]
-    end
-  end
+  # Render a MEDIUM/MD label (remove the "#" in front of each line below)
+  args.nokia.labels << { x: 0, y: 16, text: "Hello World",
+                          size_enum: NOKIA_FONT_MD,
+                          r: 0, g: 0, b: 0, a: 255,
+                          font: NOKIA_FONT_PATH }
 
-  def render_animation_frame_thumbnails
-    return if state.tick_count.zero?
+  # Render a SMALL/SM label (remove the "#" in front of each line below)
+  args.nokia.labels << { x: 0, y: 7, text: "Hello World",
+                          size_enum: NOKIA_FONT_SM,
+                          r: 0, g: 0, b: 0, a: 255,
+                          font: NOKIA_FONT_PATH }
 
-    outputs[:current_animation_frame].width   = rt_canvas.size
-    outputs[:current_animation_frame].height  = rt_canvas.size
-    outputs[:current_animation_frame].solids <<  selected_animation_frame[:pixels].map_with_index do |f, i|
-      { x: f.x,
-        y: f.y,
-        w: 1,
-        h: 1, r: 255, g: 255, b: 255 }
-    end
+  # You are provided args.nokia.default_label which returns a Hash that you
+  # can ~merge~ properties with
+  # Example 1
+  args.nokia.labels << args.nokia
+                            .default_label
+                            .merge(text: "Default")
 
-    outputs.sprites << rt_canvas.sprite.merge(path: :current_animation_frame)
+  # Example 2
+  args.nokia.labels << args.nokia
+                            .default_label
+                            .merge(x: 31,
+                                   text: "Default")
+end
 
-    state.animation_frames.map_with_index do |animation_frame, animation_frame_index|
-      outputs.sprites << state.buttons_frame_selection[:items][animation_frame_index][:inner_rect]
-                              .merge(path: animation_frame[:rt_name])
-    end
-  end
+# =============================================================================
+# ==== HOW TO RENDER FILLED SQUARES (SOLIDS) ==================================
+# =============================================================================
+def how_to_render_solids args
+  # Render a square at 0, 0 with a width and height of 1
+  args.nokia.solids << { x: 0, y: 0, w: 1, h: 1 }
 
-  def render_animation
-    sprite_index = 0.frame_index count: state.animation_frames.length,
-                                 hold_for: 60 / state.animation_frames_per_second,
-                                 repeat: true
+  # Render a square at 1, 1 with a width and height of 2
+  args.nokia.solids << { x: 1, y: 1, w: 2, h: 2 }
 
-    args.outputs.sprites << { x: 700 - 8,
-                              y: 120,
-                              w: 16,
-                              h: 16,
-                              path: (sprite_path sprite_index) }
+  # Render a square at 3, 3 with a width and height of 3
+  args.nokia.solids << { x: 3, y: 3, w: 3, h: 3 }
 
-    args.outputs.sprites << { x: 700 - 16,
-                              y: 230,
-                              w: 32,
-                              h: 32,
-                              path: (sprite_path sprite_index) }
+  # Render a square at 6, 6 with a width and height of 4
+  args.nokia.solids << { x: 6, y: 6, w: 4, h: 4 }
+end
 
-    args.outputs.sprites << { x: 700 - 32,
-                              y: 360,
-                              w: 64,
-                              h: 64,
-                              path: (sprite_path sprite_index) }
+# =============================================================================
+# ==== HOW TO RENDER UNFILLED SQUARES (BORDERS) ===============================
+# =============================================================================
+def how_to_render_borders args
+  # Render a square at 0, 0 with a width and height of 3
+  args.nokia.borders << { x: 0, y: 0, w: 3, h: 3, a: 255 }
 
-    args.outputs.sprites << { x: 700 - 64,
-                              y: 520,
-                              w: 128,
-                              h: 128,
-                              path: (sprite_path sprite_index) }
-  end
+  # Render a square at 3, 3 with a width and height of 3
+  args.nokia.borders << { x: 3, y: 3, w: 4, h: 4, a: 255 }
 
-  def input_mouse_click
-    if inputs.mouse.up
-      state.last_mouse_up = state.tick_count
-    elsif inputs.mouse.moved && user_is_editing?
-      edit_current_animation_frame inputs.mouse.point
-    end
+  # Render a square at 5, 5 with a width and height of 4
+  args.nokia.borders << { x: 7, y: 7, w: 5, h: 5, a: 255 }
+end
 
-    return unless inputs.mouse.click
+# =============================================================================
+# ==== HOW TO RENDER A LINE ===================================================
+# =============================================================================
+def how_to_render_lines args
+  # Render a horizontal line at the bottom
+  args.nokia.lines << { x: 0, y: 0, x2: 83, y2:  0 }
 
-    clicked_frame_button = state.buttons_frame_selection.items.find do |b|
-      inputs.mouse.point.inside_rect? b
-    end
+  # Render a vertical line at the left
+  args.nokia.lines << { x: 0, y: 0, x2:  0, y2: 47 }
 
-    if (clicked_frame_button)
-      state.animation_frames_selected_index = clicked_frame_button[:index]
-    end
+  # Render a diagonal line starting from the bottom left and going to the top right
+  args.nokia.lines << { x: 0, y: 0, x2: 83, y2: 47 }
+end
 
-    if (inputs.mouse.point.inside_rect? rt_canvas.sprite)
-      state.last_mouse_down = state.tick_count
-      edit_current_animation_frame inputs.mouse.point
-    end
+# =============================================================================
+# == HOW TO RENDER A SPRITE ===================================================
+# =============================================================================
+def how_to_render_sprites args
+  # Loop 10 times and create 10 sprites in 10 positions
+  # Render a sprite at the bottom left with a width and height of 5 and a path of 'sprites/monochrome-ship.png'
+  10.times do |i|
+    args.nokia.sprites << {
+      x: i * 8.4,
+      y: i * 4.8,
+      w: 5,
+      h: 5,
+      path: 'sprites/monochrome-ship.png'
+    }
   end
 
-  def input_keyboard
-    # w to save
-    if inputs.keyboard.key_down.w
-      t = Time.now
-      state.save_description = "Time: #{t} (#{t.to_i})"
-      gtk.serialize_state 'canvas/state.txt', state
-      gtk.serialize_state "tmp/canvas_backups/#{t.to_i}/state.txt", state
-      animation_frames.each_with_index do |animation_frame, i|
-        queues.update_rt_animation_frame << { index: i,
-                                              at: state.tick_count + i,
-                                              queue_sprite_creation: true }
-        queues.create_sprite << { index: i,
-                                  at: state.tick_count + animation_frames.length + i,
-                                  path_override: "tmp/canvas_backups/#{t.to_i}/sprite-#{i}.png" }
-      end
-      gtk.notify! "Canvas saved."
-    end
-
-    # l to load
-    if inputs.keyboard.key_down.l
-      args.state = gtk.deserialize_state 'canvas/state.txt'
-      animation_frames.each_with_index do |a, i|
-        queues.update_rt_animation_frame << { index: i,
-                                              at: state.tick_count + i,
-                                              queue_sprite_creation: true }
-      end
-      gtk.notify! "Canvas loaded."
-    end
+  # Given an array of positions create sprites
+  positions = [
+    { x: 20, y: 32 },
+    { x: 45, y: 15 },
+    { x: 72, y: 23 },
+  ]
 
-    # d to go into delete mode, release to paint
-    if inputs.keyboard.key_held.d
-      state.edit_mode = :erasing
-      gtk.notify! "Erasing." if inputs.keyboard.key_held.d == (state.tick_count - 1)
-    elsif inputs.keyboard.key_up.d
-      state.edit_mode = :drawing
-      gtk.notify! "Drawing."
-    end
+  positions.each do |position|
+    # use Ruby's ~Hash#merge~ function to create a sprite
+    args.nokia.sprites << position.merge(path: 'sprites/monochrome-ship.png',
+                                          w: 5,
+                                          h: 5)
+  end
+end
 
-    # a to add a frame to the end
-    if inputs.keyboard.key_down.a
-      queues.create_sprite << { index: state.animation_frames_selected_index,
-                                at: state.tick_count }
-      queues.create_sprite << { index: state.animation_frames_selected_index + 1,
-                                at: state.tick_count }
-      add_animation_frame_to_end
-      gtk.notify! "Frame added to end."
-    end
+# =============================================================================
+# ==== HOW TO ANIMATE A SPRITE (SEPERATE PNGS) ==========================
+# =============================================================================
+def how_to_animate_a_sprite args
+  # STEP 1: Define when you want the animation to start. The animation in this case will start in 3 seconds
+  start_animation_on_tick = 180
 
-    # c or t to copy
-    if (inputs.keyboard.key_down.c || inputs.keyboard.key_down.t)
-      state.clipboard = [selected_animation_frame[:pixels]].flatten
-      gtk.notify! "Current frame copied."
-    end
+  # STEP 2: Get the frame_index given the start tick.
+  sprite_index = start_animation_on_tick.frame_index count: 7,     # how many sprites?
+                                                     hold_for: 8,  # how long to hold each sprite?
+                                                     repeat: true  # should it repeat?
 
-    # v or q to paste
-    if (inputs.keyboard.key_down.v || inputs.keyboard.key_down.q) && state.clipboard
-      selected_animation_frame[:pixels] = [state.clipboard].flatten
-      queues.update_rt_animation_frame << { index: state.animation_frames_selected_index,
-                                            at: state.tick_count,
-                                            queue_sprite_creation: true }
-      gtk.notify! "Pasted."
-    end
+  # STEP 3: frame_index will return nil if the frame hasn't arrived yet
+  if sprite_index
+    # if the sprite_index is populated, use it to determine the sprite path and render it
+    sprite_path  = "sprites/explosion-#{sprite_index}.png"
+    args.nokia.sprites << { x: 42 - 16,
+                             y: 47 - 32,
+                             w: 32,
+                             h: 32,
+                             path: sprite_path }
+  else
+    # if the sprite_index is nil, render a countdown instead
+    countdown_in_seconds = ((start_animation_on_tick - args.state.tick_count) / 60).round(1)
 
-    # f to go forward/next frame
-    if (inputs.keyboard.key_down.f)
-      if (state.animation_frames_selected_index == (state.animation_frames.length - 1))
-        state.animation_frames_selected_index = 0
-      else
-        state.animation_frames_selected_index += 1
-      end
-      gtk.notify! "Next frame."
-    end
+    args.nokia.labels  << args.nokia
+                               .default_label
+                               .merge(x: 0,
+                                      y: 18,
+                                      text: "Count Down: #{countdown_in_seconds.to_sf}",
+                                      alignment_enum: 0)
+  end
 
-    # b to go back/previous frame
-    if (inputs.keyboard.key_down.b)
-      if (state.animation_frames_selected_index == 0)
-        state.animation_frames_selected_index = state.animation_frames.length - 1
-      else
-        state.animation_frames_selected_index -= 1
-      end
-      gtk.notify! "Previous frame."
-    end
+  # render the current tick and the resolved sprite index
+  args.nokia.labels  << args.nokia
+                               .default_label
+                               .merge(x: 0,
+                                      y: 11,
+                                      text: "Tick: #{args.state.tick_count}")
+  args.nokia.labels  << args.nokia
+                               .default_label
+                               .merge(x: 0,
+                                      y: 5,
+                                      text: "sprite_index: #{sprite_index}")
+end
 
-    # x to delete frame
-    if (inputs.keyboard.key_down.x) && animation_frames.length > 1
-      state.clipboard = selected_animation_frame[:pixels]
-      state.animation_frames = animation_frames.find_all { |v| v[:index] != state.animation_frames_selected_index }
-      if state.animation_frames_selected_index >= state.animation_frames.length
-        state.animation_frames_selected_index = state.animation_frames.length - 1
-      end
-      gtk.notify! "Frame deleted."
-    end
-  end
+# =============================================================================
+# ==== HOW TO ANIMATE A SPRITE (SPRITE SHEET) =================================
+# =============================================================================
+def how_to_animate_a_sprite_sheet args
+  # STEP 1: Define when you want the animation to start. The animation in this case will start in 3 seconds
+  start_animation_on_tick = 180
 
-  def calc_auto_export
-    return if user_is_editing?
-    return if state.last_mouse_up.elapsed_time != 30
-    # auto export current animation frame if there is no editing for 30 ticks
-    queues.create_sprite << { index: state.animation_frames_selected_index,
-                              at: state.tick_count }
-  end
+  # STEP 2: Get the frame_index given the start tick.
+  sprite_index = start_animation_on_tick.frame_index count: 7,     # how many sprites?
+                                                     hold_for: 8,  # how long to hold each sprite?
+                                                     repeat: true  # should it repeat?
 
-  def calc_buttons_frame_selection
-    state.buttons_frame_selection.items = animation_frames.length.map_with_index do |i|
-      { x: state.buttons_frame_selection.left + i * state.buttons_frame_selection.size,
-        y: state.buttons_frame_selection.top - state.buttons_frame_selection.size,
-        inner_rect: {
-          x: (state.buttons_frame_selection.left + 2) + i * state.buttons_frame_selection.size,
-          y: (state.buttons_frame_selection.top - state.buttons_frame_selection.size + 2),
-          w: 16,
-          h: 16,
-        },
-        w: state.buttons_frame_selection.size,
-        h: state.buttons_frame_selection.size,
-        index: i }
-    end
-  end
+  # STEP 3: frame_index will return nil if the frame hasn't arrived yet
+  if sprite_index
+    # if the sprite_index is populated, use it to determine the source rectangle and render it
+    args.nokia.sprites << {
+      x: 42 - 16,
+      y: 47 - 32,
+      w: 32,
+      h: 32,
+      path:  "sprites/explosion-sheet.png",
+      source_x: 32 * sprite_index,
+      source_y: 0,
+      source_w: 32,
+      source_h: 32
+    }
+  else
+    # if the sprite_index is nil, render a countdown instead
+    countdown_in_seconds = ((start_animation_on_tick - args.state.tick_count) / 60).round(1)
 
-  def calc_animation_frames
-    animation_frames.each_with_index do |animation_frame, i|
-      animation_frame[:index] = i
-      animation_frame[:rt_name] = "animation_frame_#{i}"
-    end
+    args.nokia.labels  << args.nokia
+                               .default_label
+                               .merge(x: 0,
+                                      y: 18,
+                                      text: "Count Down: #{countdown_in_seconds.to_sf}",
+                                      alignment_enum: 0)
   end
 
-  def process_queue_create_sprite
-    sprites_to_create = queues.create_sprite
-                              .find_all { |h| h[:at].elapsed? }
+  # render the current tick and the resolved sprite index
+  args.nokia.labels  << args.nokia
+                               .default_label
+                               .merge(x: 0,
+                                      y: 11,
+                                      text: "tick: #{args.state.tick_count}")
+  args.nokia.labels  << args.nokia
+                               .default_label
+                               .merge(x: 0,
+                                      y: 5,
+                                      text: "sprite_index: #{sprite_index}")
+end
 
-    queues.create_sprite = queues.create_sprite - sprites_to_create
+# =============================================================================
+# ==== HOW TO STORE STATE, ACCEPT INPUT, AND RENDER SPRITE BASED OFF OF STATE =
+# =============================================================================
+def how_to_move_a_sprite args
+  args.nokia.labels << args.nokia
+                            .default_label
+                            .merge(x: 42,
+                                   y: 46, text: "Use Arrow Keys",
+                                   alignment_enum: 1)
 
-    sprites_to_create.each do |h|
-      export_animation_frame h[:index], h[:path_override]
-    end
-  end
+  args.nokia.labels << args.nokia
+                            .default_label
+                            .merge(x: 42,
+                                   y: 41, text: "Or WASD",
+                                   alignment_enum: 1)
 
-  def process_queue_reset_sprite
-    sprites_to_reset = queues.reset_sprite
-                             .find_all { |h| h[:at].elapsed? }
+  args.nokia.labels << args.nokia
+                            .default_label
+                            .merge(x: 42,
+                                   y: 36, text: "Or Click",
+                                   alignment_enum: 1)
 
-    queues.reset_sprite -= sprites_to_reset
+  # set the initial values for x and y using ||= ("or equal operator")
+  args.state.ship.x ||= 0
+  args.state.ship.y ||= 0
 
-    sprites_to_reset.each { |h| gtk.reset_sprite (sprite_path h[:index]) }
+  # if a mouse click occurs, update the ship's x and y to be the location of the click
+  if args.nokia.mouse_click
+    args.state.ship.x = args.nokia.mouse_click.x
+    args.state.ship.y = args.nokia.mouse_click.y
   end
 
-  def process_queue_update_rt_animation_frame
-    animation_frames_to_update = queues.update_rt_animation_frame
-                                       .find_all { |h| h[:at].elapsed? }
+  # if a or left arrow is pressed/held, decrement the ships x position
+  if args.nokia.keyboard.left
+    args.state.ship.x -= 1
+  end
 
-    queues.update_rt_animation_frame -= animation_frames_to_update
+  # if d or right arrow is pressed/held, increment the ships x position
+  if args.nokia.keyboard.right
+    args.state.ship.x += 1
+  end
 
-    animation_frames_to_update.each do |h|
-      update_animation_frame_render_target animation_frames[h[:index]]
+  # if s or down arrow is pressed/held, decrement the ships y position
+  if args.nokia.keyboard.down
+    args.state.ship.y -= 1
+  end
 
-      if h[:queue_sprite_creation]
-        queues.create_sprite << { index: h[:index],
-                                  at: state.tick_count + 1 }
-      end
-    end
+  # if w or up arrow is pressed/held, increment the ships y position
+  if args.nokia.keyboard.up
+    args.state.ship.y += 1
   end
 
-  def update_animation_frame_render_target animation_frame
-    return if !animation_frame
+  # render the sprite to the screen using the position stored in args.state.ship
+  args.nokia.sprites << {
+    x: args.state.ship.x,
+    y: args.state.ship.y,
+    w: 5,
+    h: 5,
+    path: 'sprites/monochrome-ship.png',
+    # parameters beyond this point are optional
+    angle: 0, # Note: rotation angle is denoted in degrees NOT radians
+    r: 255,
+    g: 255,
+    b: 255,
+    a: 255
+  }
+end
 
-    outputs[animation_frame[:rt_name]].width   = state.rt_canvas.size
-    outputs[animation_frame[:rt_name]].height  = state.rt_canvas.size
-    outputs[animation_frame[:rt_name]].solids << animation_frame[:pixels].map do |f|
-      { x: f.x,
-        y: f.y,
-        w: 1,
-        h: 1, r: 255, g: 255, b: 255 }
+# =======================================================================
+# ==== HOW TO DETERMINE COLLISION =======================================
+# =======================================================================
+def how_to_determine_collision args
+  # Render the instructions
+  args.nokia.labels << args.nokia
+                            .default_label
+                            .merge(x: 42,
+                                   y: 46, text: "Click Anywhere",
+                                   alignment_enum: 1)
+
+  # if a mouse click occurs:
+  # - set ship_one if it isn't set
+  # - set ship_two if it isn't set
+  # - otherwise reset ship one and ship two
+  if args.nokia.mouse_click
+    # is ship_one set?
+    if !args.state.ship_one
+      args.state.ship_one = { x: args.nokia.mouse_click.x - 5,
+                              y: args.nokia.mouse_click.y - 5,
+                              w: 10,
+                              h: 10 }
+    # is ship_one set?
+    elsif !args.state.ship_two
+      args.state.ship_two = { x: args.nokia.mouse_click.x - 5,
+                              y: args.nokia.mouse_click.y - 5,
+                              w: 10,
+                              h: 10 }
+    # should we reset?
+    else
+      args.state.ship_one = nil
+      args.state.ship_two = nil
     end
   end
 
-  def animation_frames
-    state.animation_frames
+  # render ship one if it's set
+  if args.state.ship_one
+    # use Ruby's .merge method which is available on ~Hash~ to set the sprite and alpha
+    # render ship one
+    args.nokia.sprites << args.state.ship_one.merge(path: 'sprites/monochrome-ship.png')
   end
 
-  def add_animation_frame_to_end
-    animation_frames << {
-      index: animation_frames.length,
-      pixels: [],
-      rt_name: "animation_frame_#{animation_frames.length}"
-    }
-
-    state.animation_frames_selected_index = (animation_frames.length - 1)
-    queues.update_rt_animation_frame << { index: state.animation_frames_selected_index,
-                                          at: state.tick_count,
-                                          queue_sprite_creation: true }
+  if args.state.ship_two
+    # use Ruby's .merge method which is available on ~Hash~ to set the sprite and alpha
+    # render ship two
+    args.nokia.sprites << args.state.ship_two.merge(path: 'sprites/monochrome-ship.png')
   end
 
-  def sprite_path i
-    "canvas/sprite-#{i}.png"
+  # if both ship one and ship two are set, then determine collision
+  if args.state.ship_one && args.state.ship_two
+    # collision is determined using the intersect_rect? method
+    if args.state.ship_one.intersect_rect? args.state.ship_two
+      # if collision occurred, render the words collision!
+      args.nokia.labels << args.nokia
+                            .default_label
+                            .merge(x: 42,
+                                   y: 5,
+                                   text: "Collision!",
+                                   alignment_enum: 1)
+    else
+      # if collision occurred, render the words no collision.
+      args.nokia.labels << args.nokia
+                            .default_label
+                            .merge(x: 42,
+                                   y: 5,
+                                   text: "No Collision.",
+                                   alignment_enum: 1)
+    end
+  else
+    # if both ship one and ship two aren't set, then render --
+      args.nokia.labels << args.nokia
+                            .default_label
+                            .merge(x: 42,
+                                   y: 6,
+                                   text: "--",
+                                   alignment_enum: 1)
   end
+end
 
-  def export_animation_frame i, path_override = nil
-    return if !state.animation_frames[i]
+# =============================================================================
+# ==== HOW TO CREATE BUTTONS ==================================================
+# =============================================================================
+def how_to_create_buttons args
+  # Define a button style
+  args.state.button_style = { w: 82, h: 10, }
 
-    outputs.screenshots << state.buttons_frame_selection
-                                .items[i][:inner_rect]
-                                .merge(path: path_override || (sprite_path i))
+  # Render instructions
+  args.state.button_message ||= "Press a Button!"
+  args.nokia.labels << args.nokia
+                            .default_label
+                            .merge(x: 42,
+                                   y: 82,
+                                   text: args.state.button_message,
+                                   alignment_enum: 1)
 
-    outputs.screenshots << state.buttons_frame_selection
-                                .items[i][:inner_rect]
-                                .merge(path: "tmp/sprite_backups/#{Time.now.to_i}-sprite-#{i}.png")
 
-    queues.reset_sprite << { index: i, at: state.tick_count }
-  end
+  # Creates button one using a border and a label
+  args.state.button_one_border = args.state.button_style.merge( x: 1, y: 32)
+  args.nokia.borders << args.state.button_one_border
+  args.nokia.labels  << args.nokia
+                             .default_label
+                             .merge(x: args.state.button_one_border.x + 2,
+                                    y: args.state.button_one_border.y + NOKIA_FONT_SM_HEIGHT + 2,
+                                    text: "Button One")
 
-  def selected_animation_frame
-    state.animation_frames[state.animation_frames_selected_index]
-  end
+  # Creates button two using a border and a label
+  args.state.button_two_border = args.state.button_style.merge( x: 1, y: 20)
 
-  def edit_current_animation_frame point
-    draw_area_point = (to_draw_area point)
-    if state.edit_mode == :drawing && (!selected_animation_frame[:pixels].include? draw_area_point)
-      selected_animation_frame[:pixels] << draw_area_point
-      queues.update_rt_animation_frame << { index: state.animation_frames_selected_index,
-                                            at: state.tick_count,
-                                            queue_sprite_creation: !user_is_editing? }
-    elsif state.edit_mode == :erasing && (selected_animation_frame[:pixels].include? draw_area_point)
-      selected_animation_frame[:pixels] = selected_animation_frame[:pixels].reject { |p| p == draw_area_point }
-      queues.update_rt_animation_frame << { index: state.animation_frames_selected_index,
-                                            at: state.tick_count,
-                                            queue_sprite_creation: !user_is_editing? }
+  args.nokia.borders << args.state.button_two_border
+  args.nokia.labels << args.nokia
+                            .default_label
+                            .merge(x: args.state.button_two_border.x + 2,
+                                   y: args.state.button_two_border.y + NOKIA_FONT_SM_HEIGHT + 2,
+                                   text: "Button Two")
+
+  # Initialize the state variable that tracks which button was clicked to "" (empty stringI
+  args.state.last_button_clicked ||= "--"
+
+  # If a click occurs, check to see if either button one, or button two was clicked
+  # using the inside_rect? method of the mouse
+  # set args.state.last_button_clicked accordingly
+  if args.nokia.mouse_click
+    if args.nokia.mouse_click.inside_rect? args.state.button_one_border
+      args.state.last_button_clicked = "One Clicked!"
+    elsif args.nokia.mouse_click.inside_rect? args.state.button_two_border
+      args.state.last_button_clicked = "Two Clicked!"
+    else
+      args.state.last_button_clicked = "--"
     end
   end
 
-  def user_is_editing?
-    state.last_mouse_down > state.last_mouse_up
-  end
+  # Render the current value of args.state.last_button_clicked
+  args.nokia.labels << args.nokia
+                             .default_label
+                             .merge(x: 42,
+                                    y: 5,
+                                    text: args.state.last_button_clicked,
+                                    alignment_enum: 1)
+end
 
-  def to_draw_area point
-    x, y = point
-    x -= rt_canvas.sprite.x
-    y -= rt_canvas.sprite.y
-    { x: x.idiv(rt_canvas.zoom),
-      y: y.idiv(rt_canvas.zoom) }
+def render_debug args
+  if !args.state.grid_rendered
+    (NOKIA_HEIGHT + 1).map_with_index do |i|
+      args.outputs.static_debug << {
+        x:  NOKIA_X_OFFSET,
+        y:  NOKIA_Y_OFFSET + (i * NOKIA_ZOOM),
+        x2: NOKIA_X_OFFSET + NOKIA_ZOOMED_WIDTH,
+        y2: NOKIA_Y_OFFSET + (i * NOKIA_ZOOM),
+        r: 128,
+        g: 128,
+        b: 128,
+        a: 80
+      }.line
+    end
+
+    (NOKIA_WIDTH + 1).map_with_index do |i|
+      args.outputs.static_debug << {
+        x:  NOKIA_X_OFFSET + (i * NOKIA_ZOOM),
+        y:  NOKIA_Y_OFFSET,
+        x2: NOKIA_X_OFFSET + (i * NOKIA_ZOOM),
+        y2: NOKIA_Y_OFFSET + NOKIA_ZOOMED_HEIGHT,
+        r: 128,
+        g: 128,
+        b: 128,
+        a: 80
+      }.line
+    end
   end
 
-  def rt_canvas
-    state.rt_canvas ||= state.new_entity(:rt_canvas)
+  args.state.grid_rendered = true
+
+  args.state.last_click ||= 0
+  args.state.last_up    ||= 0
+  args.state.last_click   = args.state.tick_count if args.nokia.mouse_down # you can also use args.nokia.click
+  args.state.last_up      = args.state.tick_count if args.nokia.mouse_up
+  args.state.label_style  = { size_enum: -1.5 }
+
+  args.state.watch_list = [
+    "args.state.tick_count is:      #{args.state.tick_count}",
+    "args.nokia.mouse_position is:  #{args.nokia.mouse_position.x}, #{args.nokia.mouse_position.y}",
+    "args.nokia.mouse_down tick:    #{args.state.last_click || "never"}",
+    "args.nokia.mouse_up tick:      #{args.state.last_up || "false"}",
+  ]
+
+  args.outputs.debug << args.state
+                            .watch_list
+                            .map_with_index do |text, i|
+    {
+      x: 5,
+      y: 720 - (i * 18),
+      text: text,
+      size_enum: -1.5,
+      r: 255, g: 255, b: 255
+    }.label
   end
 
-  def queues
-    state.queues ||= state.new_entity(:queues)
-  end
+  args.outputs.debug << {
+    x: 640,
+    y:  25,
+    text: "INFO: dev mode is currently enabled. Comment out the invocation of ~render_debug~ within the ~tick~ method to hide the debug layer.",
+    size_enum: -0.5,
+    alignment_enum: 1,
+    r: 255, g: 255, b: 255
+  }.label
 end
 
-$game = OneBitLowrezPaint.new
+def snake_demo args
 
-def tick args
-  $game.args = args
-  $game.tick
 end
 
-# $gtk.reset
-
-
-Dev Tools - Tile Editor Starting Point - main.rb
-# ./samples/99_genre_dev_tools/tile_editor_starting_point/app/main.rb
-=begin
-
- APIs listing that haven't been encountered in previous sample apps:
-
- - to_s: Returns a string representation of an object.
-   For example, if we had
-   500.to_s
-   the string "500" would be returned.
-   Similar to to_i, which returns an integer representation of an object.
-
- - Ceil: Returns an integer number greater than or equal to the original
-   with no decimal.
-
- Reminders:
+$gtk.reset
 
- - ARRAY#inside_rect?: Returns true or false depending on if the point is inside a rect.
+
+Lowrez - Nokia 3310 - nokia.rb
+# ./samples/99_genre_lowrez/nokia_3310/app/nokia.rb
+# Emulation of a 64x64 canvas. Don't change this file unless you know what you're doing :-)
+# Head over to main.rb and study the code there.
 
- - args.outputs.labels: An array. The values generate a label.
-   The parameters are [X, Y, TEXT, SIZE, ALIGNMENT, RED, GREEN, BLUE, ALPHA, FONT STYLE]
-   For more information about labels, go to mygame/documentation/02-labels.md.
+NOKIA_WIDTH           = 84
+NOKIA_HEIGHT          = 48
+NOKIA_ZOOM            = 12
+NOKIA_ZOOMED_WIDTH    = NOKIA_WIDTH  * NOKIA_ZOOM
+NOKIA_ZOOMED_HEIGHT   = NOKIA_HEIGHT * NOKIA_ZOOM
+NOKIA_X_OFFSET        = (1280 - NOKIA_ZOOMED_WIDTH).half
+NOKIA_Y_OFFSET        = ( 720 - NOKIA_ZOOMED_HEIGHT).half
 
- - args.outputs.sprites: An array. The values generate a sprite.
-   The parameters are [X, Y, WIDTH, HEIGHT, IMAGE PATH]
-   For more information about sprites, go to mygame/documentation/05-sprites.md.
+NOKIA_FONT_XL         = -1
+NOKIA_FONT_XL_HEIGHT  = 20
 
- - args.outputs.solids: An array. The values generate a solid.
-   The parameters are [X, Y, WIDTH, HEIGHT, RED, GREEN, BLUE]
-   For more information about solids, go to mygame/documentation/03-solids-and-borders.md.
+NOKIA_FONT_LG         = -3.5
+NOKIA_FONT_LG_HEIGHT  = 15
 
- - args.outputs.lines: An array. The values generate a line.
-   The parameters are [X1, Y1, X2, Y2, RED, GREEN, BLUE]
-   For more information about lines, go to mygame/documentation/04-lines.md.
+NOKIA_FONT_MD         = -6
+NOKIA_FONT_MD_HEIGHT  = 10
 
- - args.state.new_entity: Used when we want to create a new object, like a sprite or button.
-   In this sample app, new_entity is used to create a new button that clears the grid.
-   (Remember, you can use state to define ANY property and it will be retained across frames.)
+NOKIA_FONT_SM         = -8.5
+NOKIA_FONT_SM_HEIGHT  = 5
 
-=end
+NOKIA_FONT_PATH       = 'fonts/lowrez.ttf'
 
-# This sample app shows an empty grid that the user can paint in. There are different image tiles that
-# the user can use to fill the grid, and the "Clear" button can be pressed to clear the grid boxes.
 
-class TileEditor
-  attr_accessor :inputs, :state, :outputs, :grid, :args
+class NokiaOutputs
+  attr_accessor :width, :height
 
-  # Runs all the methods necessary for the game to function properly.
-  def tick
-    defaults
-    render
-    check_click
-    draw_buttons
+  def initialize args
+    @args = args
   end
 
-  # Sets default values
-  # Initialization only happens in the first frame
-  # NOTE: The values of some of these variables may seem confusingly large at first.
-  # The gridSize is 1600 but it seems a lot smaller on the screen, for example.
-  # But keep in mind that by using the "W", "A", "S", and "D" keys, you can
-  # move the grid's view in all four directions for more grid spaces.
-  def defaults
-    state.tileCords      ||= []
-    state.tileQuantity   ||= 6
-    state.tileSize       ||= 50
-    state.tileSelected   ||= 1
-    state.tempX          ||= 50
-    state.tempY          ||= 500
-    state.speed          ||= 4
-    state.centerX        ||= 4000
-    state.centerY        ||= 4000
-    state.originalCenter ||= [state.centerX, state.centerY]
-    state.gridSize       ||= 1600
-    state.lineQuantity   ||= 50
-    state.increment      ||= state.gridSize / state.lineQuantity
-    state.gridX          ||= []
-    state.gridY          ||= []
-    state.filled_squares ||= []
-    state.grid_border    ||= [390, 140, 500, 500]
-
-    get_grid unless state.tempX == 0 # calls get_grid in the first frame only
-    determineTileCords unless state.tempX == 0 # calls determineTileCords in first frame
-    state.tempX = 0 # sets tempX to 0; the two methods aren't called again
+  def outputs_nokia
+    return @args.outputs if @args.state.tick_count <= 0
+    return @args.outputs[:nokia]
   end
 
-  # Calculates the placement of lines or separators in the grid
-  def get_grid
-    curr_x = state.centerX - (state.gridSize / 2) # starts at left of grid
-    deltaX = state.gridSize / state.lineQuantity # finds distance to place vertical lines evenly through width of grid
-    (state.lineQuantity + 2).times do
-      state.gridX << curr_x # adds curr_x to gridX collection
-      curr_x += deltaX # increment curr_x by the distance between vertical lines
-    end
-
-    curr_y = state.centerY - (state.gridSize / 2) # starts at bottom of grid
-    deltaY = state.gridSize / state.lineQuantity # finds distance to place horizontal lines evenly through height of grid
-    (state.lineQuantity + 2).times do
-      state.gridY << curr_y # adds curr_y to gridY collection
-      curr_y += deltaY # increments curr_y to distance between horizontal lines
-    end
+  def solids
+    outputs_nokia.solids
   end
 
-  # Determines coordinate positions of patterned tiles (on the left side of the grid)
-  def determineTileCords
-    state.tempCounter ||= 1 # initializes tempCounter to 1
-    state.tileQuantity.times do # there are 6 different kinds of tiles
-      state.tileCords += [[state.tempX, state.tempY, state.tempCounter]] # adds tile definition to collection
-      state.tempX += 75 # increments tempX to put horizontal space between the patterned tiles
-      state.tempCounter += 1 # increments tempCounter
-      if state.tempX > 200 # if tempX exceeds 200 pixels
-        state.tempX = 50 # a new row of patterned tiles begins
-        state.tempY -= 75 # the new row is 75 pixels lower than the previous row
-      end
-    end
+  def borders
+    outputs_nokia.borders
   end
 
-  # Outputs objects (grid, tiles, etc) onto the screen
-  def render
-    outputs.sprites << state.tileCords.map do # outputs tileCords collection using images in sprites folder
-      |x, y, order|
-      [x, y, state.tileSize, state.tileSize, 'sprites/image' + order.to_s + ".png"]
-    end
-    outputs.solids << [0, 0, 1280, 720, 255, 255, 255] # outputs white background
-    add_grid # outputs grid
-    print_title # outputs title and current tile pattern
+  def sprites
+    outputs_nokia.sprites
   end
 
-  # Creates a grid by outputting vertical and horizontal grid lines onto the screen.
-  # Outputs sprites for the filled_squares collection onto the screen.
-  def add_grid
-
-    # Outputs the grid's border.
-    outputs.borders << state.grid_border
-    temp = 0
-
-    # Before looking at the code that outputs the vertical and horizontal lines in the
-    # grid, take note of the fact that:
-    # grid_border[1] refers to the border's bottom line (running horizontally),
-    # grid_border[2] refers to the border's top line (running (horizontally),
-    # grid_border[0] refers to the border's left line (running vertically),
-    # and grid_border[3] refers to the border's right line (running vertically).
-
-    #           [2]
-    #       ----------
-    #       |        |
-    # [0]   |        | [3]
-    #       |        |
-    #       ----------
-    #           [1]
-
-    # Calculates the positions and outputs the x grid lines in the color gray.
-    state.gridX.map do # perform an action on all elements of the gridX collection
-      |x|
-      temp += 1 # increment temp
-
-      # if x's value is greater than (or equal to) the x value of the border's left side
-      # and less than (or equal to) the x value of the border's right side
-      if x >= state.centerX - (state.grid_border[2] / 2) && x <= state.centerX + (state.grid_border[2] / 2)
-        delta = state.centerX - 640
-        # vertical lines have the same starting and ending x positions
-        # starting y and ending y positions lead from the bottom of the border to the top of the border
-        outputs.lines << [x - delta, state.grid_border[1], x - delta, state.grid_border[1] + state.grid_border[2], 150, 150, 150] # sets definition of vertical line and outputs it
-      end
-    end
-    temp = 0
-
-    # Calculates the positions and outputs the y grid lines in the color gray.
-    state.gridY.map do # perform an action on all elements of the gridY collection
-      |y|
-      temp += 1 # increment temp
+  def labels
+    outputs_nokia.labels
+  end
 
-      # if y's value is greater than (or equal to) the y value of the border's bottom side
-      # and less than (or equal to) the y value of the border's top side
-      if y >= state.centerY - (state.grid_border[3] / 2) && y <= state.centerY + (state.grid_border[3] / 2)
-        delta = state.centerY - 393
-        # horizontal lines have the same starting and ending y positions
-        # starting x and ending x positions lead from the left side of the border to the right side of the border
-        outputs.lines << [state.grid_border[0], y - delta, state.grid_border[0] + state.grid_border[3], y - delta, 150, 150, 150] # sets definition of horizontal line and outputs it
-      end
-    end
+  def default_label
+    {
+      x: 0,
+      y: 63,
+      text: "",
+      size_enum: NOKIA_FONT_SM,
+      alignment_enum: 0,
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 255,
+      font: NOKIA_FONT_PATH
+    }
+  end
 
-    # Sets values and outputs sprites for the filled_squares collection.
-    state.filled_squares.map do # perform an action on every element of the filled_squares collection
-      |x, y, w, h, sprite|
-        # if x's value is greater than (or equal to) the x value of 17 pixels to the left of the border's left side
-        # and less than (or equal to) the x value of the border's right side
-        # and y's value is greater than (or equal to) the y value of the border's bottom side
-        # and less than (or equal to) the y value of 25 pixels above the border's top side
-        # NOTE: The allowance of 17 pixels and 25 pixels is due to the fact that a grid box may be slightly cut off or
-        # not entirely visible in the grid's view (until it is moved using "W", "A", "S", "D")
-        if x >= state.centerX - (state.grid_border[2] / 2) - 17 && x <= state.centerX + (state.grid_border[2] / 2) &&
-           y >= state.centerY - (state.grid_border[3] / 2) && y <= state.centerY + (state.grid_border[3] / 2) + 25
-          # calculations done to place sprites in grid spaces that are meant to filled in
-          # mess around with the x and y values and see how the sprite placement changes
-          outputs.sprites << [x - state.centerX + 630, y - state.centerY + 360, w, h, sprite]
-        end
-      end
+  def lines
+    outputs_nokia.lines
+  end
 
-      # outputs a white solid along the left side of the grid (change the color and you'll be able to see it against the white background)
-      # state.increment subtracted in x parameter because solid's position is denoted by bottom left corner
-      # state.increment subtracted in y parameter to avoid covering the title label
-      outputs.primitives << [state.grid_border[0] - state.increment,
-                             state.grid_border[1] - state.increment, state.increment, state.grid_border[3] + (state.increment * 2),
-                             255, 255, 255].solid
+  def primitives
+    outputs_nokia.primitives
+  end
 
-      # outputs a white solid along the right side of the grid
-      # state.increment subtracted from y parameter to avoid covering title label
-      outputs.primitives << [state.grid_border[0] + state.grid_border[2],
-                             state.grid_border[1] - state.increment, state.increment, state.grid_border[3] + (state.increment * 2),
-                             255, 255, 255].solid
+  def click
+    return nil unless @args.inputs.mouse.click
+    mouse
+  end
 
-      # outputs a white solid along the bottom of the grid
-      # state.increment subtracted from y parameter to avoid covering last row of grid boxes
-      outputs.primitives << [state.grid_border[0] - state.increment, state.grid_border[1] - state.increment,
-                             state.grid_border[2] + (2 * state.increment), state.increment, 255, 255, 255].solid
+  def mouse_click
+    click
+  end
 
-      # outputs a white solid along the top of the grid
-      outputs.primitives << [state.grid_border[0] - state.increment, state.grid_border[1] + state.grid_border[3],
-                             state.grid_border[2] + (2 * state.increment), state.increment, 255, 255, 255].solid
+  def mouse_down
+    @args.inputs.mouse.down
+  end
 
+  def mouse_up
+    @args.inputs.mouse.up
   end
 
-  # Outputs title and current tile pattern
-  def print_title
-    outputs.labels << [640, 700, 'Mouse to Place Tile, WASD to Move Around', 7, 1] # title label
-    outputs.lines << horizontal_separator(660, 0, 1280) # outputs horizontal separator
-    outputs.labels << [1050, 500, 'Current:', 3, 1] # outputs Current label
-    outputs.sprites << [1110, 474, state.tileSize / 2, state.tileSize / 2, 'sprites/image' + state.tileSelected.to_s + ".png"] # outputs sprite of current tile pattern using images in sprites folder; output is half the size of a tile
+  def mouse
+    [
+      ((@args.inputs.mouse.x - NOKIA_X_OFFSET).idiv(NOKIA_ZOOM)),
+      ((@args.inputs.mouse.y - NOKIA_Y_OFFSET).idiv(NOKIA_ZOOM))
+    ]
   end
 
-  # Sets the starting position, ending position, and color for the horizontal separator.
-  def horizontal_separator y, x, x2
-    [x, y, x2, y, 150, 150, 150] # definition of separator; horizontal line means same starting/ending y
+  def mouse_position
+    mouse
   end
 
-  # Checks if the mouse is being clicked or dragged
-  def check_click
-    if inputs.keyboard.key_down.r # if the "r" key is pressed down
-      $dragon.reset
-    end
-
-    if inputs.mouse.down #is mouse up or down?
-      state.mouse_held = true
-      if inputs.mouse.position.x < state.grid_border[0] # if mouse's x position is inside the grid's borders
-        state.tileCords.map do # perform action on all elements of tileCords collection
-          |x, y, order|
-          # if mouse's x position is greater than (or equal to) the starting x position of a tile
-          # and the mouse's x position is also less than (or equal to) the ending x position of that tile,
-          # and the mouse's y position is greater than (or equal to) the starting y position of that tile,
-          # and the mouse's y position is also less than (or equal to) the ending y position of that tile,
-          # (BASICALLY, IF THE MOUSE'S POSITION IS WITHIN THE STARTING AND ENDING POSITIONS OF A TILE)
-          if inputs.mouse.position.x >= x && inputs.mouse.position.x <= x + state.tileSize &&
-             inputs.mouse.position.y >= y && inputs.mouse.position.y <= y + state.tileSize
-            state.tileSelected = order # that tile is selected
-          end
-        end
-      end
-    elsif inputs.mouse.up # otherwise, if the mouse is in the "up" state
-      state.mouse_held = false # mouse is not held down or dragged
-      state.mouse_dragging = false
-    end
+  def keyboard
+    @args.inputs.keyboard
+  end
+end
 
-    if state.mouse_held &&    # mouse needs to be down
-       !inputs.mouse.click &&     # must not be first click
-       ((inputs.mouse.previous_click.point.x - inputs.mouse.position.x).abs > 15 ||
-        (inputs.mouse.previous_click.point.y - inputs.mouse.position.y).abs > 15) # Need to move 15 pixels before "drag"
-      state.mouse_dragging = true
-    end
+class GTK::Args
+  def init_nokia
+    return if @nokia
+    @nokia = NokiaOutputs.new self
+  end
 
-    # if mouse is clicked inside grid's border, search_lines method is called with click input type
-    if ((inputs.mouse.click) && (inputs.mouse.click.point.inside_rect? state.grid_border))
-      search_lines(inputs.mouse.click.point, :click)
+  def nokia
+    @nokia
+  end
+end
 
-    # if mouse is dragged inside grid's border, search_lines method is called with drag input type
-    elsif ((state.mouse_dragging) && (inputs.mouse.position.inside_rect? state.grid_border))
-      search_lines(inputs.mouse.position, :drag)
-    end
+module GTK
+  class Runtime
+    alias_method :__original_tick_core__, :tick_core unless Runtime.instance_methods.include?(:__original_tick_core__)
 
-    # Changes grid's position on screen by moving it up, down, left, or right.
+    def tick_core
+      @args.init_nokia
 
-    # centerX is incremented by speed if the "d" key is pressed and if that sum is less than
-    # the original left side of the center plus half the grid, minus half the top border of grid.
-    # MOVES GRID RIGHT (increasing x)
-    state.centerX += state.speed if inputs.keyboard.key_held.d &&
-                                    (state.centerX + state.speed) < state.originalCenter[0] + (state.gridSize / 2) - (state.grid_border[2] / 2)
-    # centerX is decremented by speed if the "a" key is pressed and if that difference is greater than
-    # the original left side of the center minus half the grid, plus half the top border of grid.
-    # MOVES GRID LEFT (decreasing x)
-    state.centerX -= state.speed if inputs.keyboard.key_held.a &&
-                                    (state.centerX - state.speed) > state.originalCenter[0] - (state.gridSize / 2) + (state.grid_border[2] / 2)
-    # centerY is incremented by speed if the "w" key is pressed and if that sum is less than
-    # the original bottom of the center plus half the grid, minus half the right border of grid.
-    # MOVES GRID UP (increasing y)
-    state.centerY += state.speed if inputs.keyboard.key_held.w &&
-                                    (state.centerY + state.speed) < state.originalCenter[1] + (state.gridSize / 2) - (state.grid_border[3] / 2)
-    # centerY is decremented by speed if the "s" key is pressed and if the difference is greater than
-    # the original bottom of the center minus half the grid, plus half the right border of grid.
-    # MOVES GRID DOWN (decreasing y)
-    state.centerY -= state.speed if inputs.keyboard.key_held.s &&
-                                    (state.centerY - state.speed) > state.originalCenter[1] - (state.gridSize / 2) + (state.grid_border[3] / 2)
-  end
+      __original_tick_core__
 
-  # Performs calculations on the gridX and gridY collections, and sets values.
-  # Sets the definition of a grid box, including the image that it is filled with.
-  def search_lines (point, input_type)
-    point.x += state.centerX - 630 # increments x and y
-    point.y += state.centerY - 360
-    findX = 0
-    findY = 0
-    increment = state.gridSize / state.lineQuantity # divides grid by number of separators
+      return if @args.state.tick_count <= 0
 
-    state.gridX.map do # perform an action on every element of collection
-      |x|
-      # findX increments x by 10 if point.x is less than that sum and findX is currently 0
-      findX = x + 10 if point.x < (x + 10) && findX == 0
-    end
+      @args.render_target(:nokia)
+           .labels
+           .each do |l|
+        l.y  += 1
+        if (l.a || 255) > 128
+          l.r = 67
+          l.g = 82
+          l.b = 61
+          l.a = 255
+        else
+          l.a = 0
+        end
+      end
 
-    state.gridY.map do
-      |y|
-      # findY is set to y if point.y is less than that value and findY is currently 0
-      findY = y if point.y < (y) && findY == 0
-    end
-    # position of a box is denoted by bottom left corner, which is why the increment is being subtracted
-    grid_box = [findX - (increment.ceil), findY - (increment.ceil), increment.ceil, increment.ceil,
-                "sprites/image" + state.tileSelected.to_s + ".png"] # sets sprite definition
+      @args.render_target(:nokia)
+           .sprites
+           .each do |s|
+        if (s.a || 255) > 128
+          s.a = 255
+        else
+          s.a = 0
+        end
+      end
 
-    if input_type == :click # if user clicks their mouse
-      if state.filled_squares.include? grid_box # if grid box is already filled in
-        state.filled_squares.delete grid_box # box is cleared and removed from filled_squares
-      else
-        state.filled_squares << grid_box # otherwise, box is filled in and added to filled_squares
+      @args.render_target(:nokia)
+           .solids
+           .each do |s|
+        if (s.a || 255) > 128
+          s.r = 67
+          s.g = 82
+          s.b = 61
+          s.a = 255
+        else
+          s.a = 0
+        end
       end
-    elsif input_type == :drag # if user drags mouse
-      unless state.filled_squares.include? grid_box # unless grid box dragged over is already filled in
-        state.filled_squares << grid_box # box is filled in and added to filled_squares
+
+      @args.render_target(:nokia)
+           .borders
+           .each do |s|
+        if (s.a || 255) > 128
+          s.r = 67
+          s.g = 82
+          s.b = 61
+          s.a = 255
+        else
+          s.a = 0
+        end
       end
-    end
-  end
 
-  # Creates a "Clear" button using labels and borders.
-  def draw_buttons
-    x, y, w, h = 390, 50, 240, 50
-    state.clear_button        ||= state.new_entity(:button_with_fade)
+      @args.render_target(:nokia)
+           .lines
+           .each do |l|
+        l.y  += 1
+        l.y2 += 1
+        l.y2 += 1 if l.y1 != l.y2
+        l.x2 += 1 if l.x1 != l.x2
 
-    # x and y positions are set to display "Clear" label in center of the button
-    # Try changing first two parameters to simply x, y and see what happens to the text placement
-    state.clear_button.label  ||= [x + w.half, y + h.half + 10, "Clear", 0, 1]
-    state.clear_button.border ||= [x, y, w, h] # definition of button's border
+        if (l.a || 255) > 128
+          l.r = 67
+          l.g = 82
+          l.b = 61
+          l.a = 255
+        else
+          l.a = 0
+        end
+      end
 
-    # If the mouse is clicked inside the borders of the clear button
-    if inputs.mouse.click && inputs.mouse.click.point.inside_rect?(state.clear_button.border)
-      state.clear_button.clicked_at = inputs.mouse.click.created_at # value is frame of mouse click
-      state.filled_squares.clear # filled squares collection is emptied (squares are cleared)
-      inputs.mouse.previous_click = nil # no previous click
-    end
+      @args.outputs.borders << {
+        x: NOKIA_X_OFFSET      - 1,
+        y: NOKIA_Y_OFFSET      - 1,
+        w: NOKIA_ZOOMED_WIDTH  + 2,
+        h: NOKIA_ZOOMED_HEIGHT + 2,
+        r: 128, g: 128, b: 128
+      }
 
-    outputs.labels << state.clear_button.label # outputs clear button
-    outputs.borders << state.clear_button.border
 
-    # When the clear button is clicked, the color of the button changes
-    # and the transparency changes, as well. If you change the time from
-    # 0.25.seconds to 1.25.seconds or more, the change will last longer.
-    if state.clear_button.clicked_at
-      outputs.solids << [x, y, w, h, 0, 180, 80, 255 * state.clear_button.clicked_at.ease(0.25.seconds, :flip)]
-    end
-  end
-end
+      @args.outputs.background_color = [199, 240, 216]
 
-$tile_editor = TileEditor.new
+      @args.outputs.solids << [0, 0, NOKIA_X_OFFSET, 720]
+      @args.outputs.solids << [0, 0, 1280, NOKIA_Y_OFFSET]
+      @args.outputs.solids << [NOKIA_X_OFFSET + NOKIA_ZOOMED_WIDTH, 0, NOKIA_X_OFFSET, 720]
+      @args.outputs.solids << [0, NOKIA_Y_OFFSET.from_top, 1280, NOKIA_Y_OFFSET]
 
-def tick args
-  $tile_editor.inputs = args.inputs
-  $tile_editor.grid = args.grid
-  $tile_editor.args = args
-  $tile_editor.outputs = args.outputs
-  $tile_editor.state = args.state
-  $tile_editor.tick
-  tick_instructions args, "Roll your own tile editor. CLICK to select a sprite. CLICK in grid to place sprite. WASD to move around."
-end
+      @args.outputs
+           .sprites << { x: NOKIA_X_OFFSET,
+                         y: NOKIA_Y_OFFSET,
+                         w: NOKIA_ZOOMED_WIDTH,
+                         h: NOKIA_ZOOMED_HEIGHT,
+                         source_x: 0,
+                         source_y: 0,
+                         source_w: NOKIA_WIDTH,
+                         source_h: NOKIA_HEIGHT,
+                         path: :nokia }
+
+      if !@args.state.overlay_rendered
+        (NOKIA_HEIGHT + 1).map_with_index do |i|
+          @args.outputs.static_lines << {
+            x:  NOKIA_X_OFFSET,
+            y:  NOKIA_Y_OFFSET + (i * NOKIA_ZOOM),
+            x2: NOKIA_X_OFFSET + NOKIA_ZOOMED_WIDTH,
+            y2: NOKIA_Y_OFFSET + (i * NOKIA_ZOOM),
+            r: 199,
+            g: 240,
+            b: 216,
+            a: 100
+          }.line
+        end
 
-def tick_instructions args, text, y = 715
-  return if args.state.key_event_occurred
-  if args.inputs.mouse.click ||
-     args.inputs.keyboard.directional_vector ||
-     args.inputs.keyboard.key_down.enter ||
-     args.inputs.keyboard.key_down.escape
-    args.state.key_event_occurred = true
-  end
+        (NOKIA_WIDTH + 1).map_with_index do |i|
+          @args.outputs.static_lines << {
+            x:  NOKIA_X_OFFSET + (i * NOKIA_ZOOM),
+            y:  NOKIA_Y_OFFSET,
+            x2: NOKIA_X_OFFSET + (i * NOKIA_ZOOM),
+            y2: NOKIA_Y_OFFSET + NOKIA_ZOOMED_HEIGHT,
+            r: 199,
+            g: 240,
+            b: 216,
+            a: 100
+          }.line
+        end
 
-  args.outputs.debug << [0, y - 50, 1280, 60].solid
-  args.outputs.debug << [640, y, text, 1, 1, 255, 255, 255].label
-  args.outputs.debug << [640, y - 25, "(click to dismiss instructions)" , -2, 1, 255, 255, 255].label
+        @args.state.overlay_rendered = true
+      end
+    end
+  end
 end
 
-

-Lowrez - Resolution 64x64 - lowrez.rb
-# ./samples/99_genre_lowrez/resolution_64x64/app/lowrez.rb
+
+Lowrez - Resolution 64x64 - lowrez.rb
+# ./samples/99_genre_lowrez/resolution_64x64/app/lowrez.rb
 # Emulation of a 64x64 canvas. Don't change this file unless you know what you're doing :-)
 # Head over to main.rb and study the code there.
 
@@ -13340,9 +26076,9 @@ module GTK
   end
 end
 
-

-Lowrez - Resolution 64x64 - main.rb
-# ./samples/99_genre_lowrez/resolution_64x64/app/main.rb
+
+Lowrez - Resolution 64x64 - main.rb
+# ./samples/99_genre_lowrez/resolution_64x64/app/main.rb
 require 'app/lowrez.rb'
 
 def tick args
@@ -13957,9 +26693,9 @@ end
 
 $gtk.reset
 
-

-Platformer - Clepto Frog - main.rb
-# ./samples/99_genre_platformer/clepto_frog/app/main.rb
+
+Platformer - Clepto Frog - main.rb
+# ./samples/99_genre_platformer/clepto_frog/app/main.rb
 MAP_FILE_PATH = 'app/map.txt'
 
 require 'app/map.rb'
@@ -14825,9 +27561,9 @@ def tick_instructions args, text, y = 715
   args.outputs.debug << [640, y - 25, "(SPACE to dismiss instructions)" , -2, 1, 255, 255, 255].label
 end
 
-

-Platformer - Clepto Frog - map.rb
-# ./samples/99_genre_platformer/clepto_frog/app/map.rb
+
+Platformer - Clepto Frog - map.rb
+# ./samples/99_genre_platformer/clepto_frog/app/map.rb
 $collisions = [
   [326, 463, 64, 64],
   [274, 462, 64, 64],
@@ -15854,16 +28590,16 @@ $mugs = [
   [5064, 1064, 39, 43, "sprites/square-orange.png"]
 ]
 
-

-Platformer - Gorillas Basic - credits.txt
-# ./samples/99_genre_platformer/gorillas_basic/CREDITS.txt
+
+Platformer - Gorillas Basic - credits.txt
+# ./samples/99_genre_platformer/gorillas_basic/CREDITS.txt
 code: Amir Rajan, https://twitter.com/amirrajan
 graphics: Nick Culbertson, https://twitter.com/MobyPixel
 
 
-

-Platformer - Gorillas Basic - main.rb
-# ./samples/99_genre_platformer/gorillas_basic/app/main.rb
+
+Platformer - Gorillas Basic - main.rb
+# ./samples/99_genre_platformer/gorillas_basic/app/main.rb
 class YouSoBasicGorillas
   attr_accessor :outputs, :grid, :state, :inputs
 
@@ -16238,17 +28974,17 @@ def tick args
   $you_so_basic_gorillas.tick
 end
 
-

-Platformer - Gorillas Basic - tests.rb
-# ./samples/99_genre_platformer/gorillas_basic/app/tests.rb
+
+Platformer - Gorillas Basic - tests.rb
+# ./samples/99_genre_platformer/gorillas_basic/app/tests.rb
 $gtk.reset 100
 $gtk.supress_framerate_warning = true
 $gtk.require 'app/tests/building_generation_tests.rb'
 $gtk.tests.start
 
-

-Platformer - Gorillas Basic - Tests - building_generation_tests.rb
-# ./samples/99_genre_platformer/gorillas_basic/app/tests/building_generation_tests.rb
+
+Platformer - Gorillas Basic - Tests - building_generation_tests.rb
+# ./samples/99_genre_platformer/gorillas_basic/app/tests/building_generation_tests.rb
 def test_solids args, assert
   game = YouSoBasicGorillas.new
   game.outputs = args.outputs
@@ -16265,9 +29001,9 @@ def test_solids args, assert
   assert.true! static_solids == the_only_background.+(number_of_building_components), "not all parts of the buildings and background were rendered"
 end
 
-

-Platformer - The Little Probe - main.rb
-# ./samples/99_genre_platformer/the_little_probe/app/main.rb
+
+Platformer - The Little Probe - main.rb
+# ./samples/99_genre_platformer/the_little_probe/app/main.rb
 class FallingCircle
   attr_gtk
 
@@ -17156,9 +29892,9 @@ def reset
   $game = nil
 end
 
-

-Platformer - The Little Probe - Data - level.txt
-# ./samples/99_genre_platformer/the_little_probe/data/level.txt
+
+Platformer - The Little Probe - Data - level.txt
+# ./samples/99_genre_platformer/the_little_probe/data/level.txt
 640,8840,1180,8840
 -60,10220,0,9960
 -60,10220,0,10500
@@ -18640,9 +31376,9 @@ end
 1600,11320,1910,11280
 1910,11280,2200,11180
 923.0029599285435,11398.99893503157,1264.002959928544,11351.99893503157
-

-Platformer - The Little Probe - Data - level_lava.txt
-# ./samples/99_genre_platformer/the_little_probe/data/level_lava.txt
+
+Platformer - The Little Probe - Data - level_lava.txt
+# ./samples/99_genre_platformer/the_little_probe/data/level_lava.txt
 100,10740,500,10780
 500,10780,960,10760
 960,10760,1340,10760
@@ -18878,9 +31614,9 @@ end
 1480,11280,1840,11230
 2200,11130,2360,11090
 1840,11230,2200,11130
-

-Rpg Narrative - Choose Your Own Adventure - decision.rb
-# ./samples/99_genre_rpg_narrative/choose_your_own_adventure/app/decision.rb
+
+Rpg Narrative - Choose Your Own Adventure - decision.rb
+# ./samples/99_genre_rpg_narrative/choose_your_own_adventure/app/decision.rb
 # Hey there! Welcome to Four Decisions. Here is how you
 # create your decision tree. Remove =being and =end from the text to
 # enable the game (just save the file). Change stuff and see what happens!
@@ -18919,9 +31655,9 @@ def game
   }
 end
 
-

-Rpg Narrative - Choose Your Own Adventure - main.rb
-# ./samples/99_genre_rpg_narrative/choose_your_own_adventure/app/main.rb
+
+Rpg Narrative - Choose Your Own Adventure - main.rb
+# ./samples/99_genre_rpg_narrative/choose_your_own_adventure/app/main.rb
 =begin
 
  Reminders:
@@ -19055,9 +31791,9 @@ end
 # Resets the game.
 $gtk.reset
 
-

-Rpg Narrative - Return Of Serenity - lowrez_simulator.rb
-# ./samples/99_genre_rpg_narrative/return_of_serenity/app/lowrez_simulator.rb
+
+Rpg Narrative - Return Of Serenity - lowrez_simulator.rb
+# ./samples/99_genre_rpg_narrative/return_of_serenity/app/lowrez_simulator.rb
 ###################################################################################
 # YOU CAN PLAY AROUND WITH THE CODE BELOW, BUT USE CAUTION AS THIS IS WHAT EMULATES
 # THE 64x64 CANVAS.
@@ -19150,9 +31886,9 @@ def render_gridlines_if_needed args
   end
 end
 
-

-Rpg Narrative - Return Of Serenity - main.rb
-# ./samples/99_genre_rpg_narrative/return_of_serenity/app/main.rb
+
+Rpg Narrative - Return Of Serenity - main.rb
+# ./samples/99_genre_rpg_narrative/return_of_serenity/app/main.rb
 require 'app/require.rb'
 
 def defaults args
@@ -19627,9 +32363,9 @@ def player_xs args, x, y
   [x, y, 1, 4, 'sprites/player-zoomed-out.png', 0, (global_alpha_percentage args)]
 end
 
-

-Rpg Narrative - Return Of Serenity - require.rb
-# ./samples/99_genre_rpg_narrative/return_of_serenity/app/require.rb
+
+Rpg Narrative - Return Of Serenity - require.rb
+# ./samples/99_genre_rpg_narrative/return_of_serenity/app/require.rb
 require 'app/lowrez_simulator.rb'
 require 'app/storyline_day_one.rb'
 require 'app/storyline_blinking_light.rb'
@@ -19642,9 +32378,9 @@ require 'app/storyline_final_message.rb'
 require 'app/storyline_final_decision.rb'
 require 'app/storyline.rb'
 
-

-Rpg Narrative - Return Of Serenity - storyline.rb
-# ./samples/99_genre_rpg_narrative/return_of_serenity/app/storyline.rb
+
+Rpg Narrative - Return Of Serenity - storyline.rb
+# ./samples/99_genre_rpg_narrative/return_of_serenity/app/storyline.rb
 def hotspot_top
   [4, 61, 56, 3]
 end
@@ -19792,9 +32528,9 @@ def reload_current_scene
   $gtk.console.close
 end
 
-

-Rpg Narrative - Return Of Serenity - storyline_anka.rb
-# ./samples/99_genre_rpg_narrative/return_of_serenity/app/storyline_anka.rb
+
+Rpg Narrative - Return Of Serenity - storyline_anka.rb
+# ./samples/99_genre_rpg_narrative/return_of_serenity/app/storyline_anka.rb
 def anka_inside_room args
   {
     background: 'sprites/inside-home.png',
@@ -19923,9 +32659,9 @@ def replied_to_anka_back_home args
   end
 end
 
-

-Rpg Narrative - Return Of Serenity - storyline_blinking_light.rb
-# ./samples/99_genre_rpg_narrative/return_of_serenity/app/storyline_blinking_light.rb
+
+Rpg Narrative - Return Of Serenity - storyline_blinking_light.rb
+# ./samples/99_genre_rpg_narrative/return_of_serenity/app/storyline_blinking_light.rb
 def the_blinking_light args
   {
     fade: 60,
@@ -20002,9 +32738,9 @@ def blinking_light_inside_mainframe args
   }
 end
 
-

-Rpg Narrative - Return Of Serenity - storyline_day_one.rb
-# ./samples/99_genre_rpg_narrative/return_of_serenity/app/storyline_day_one.rb
+
+Rpg Narrative - Return Of Serenity - storyline_day_one.rb
+# ./samples/99_genre_rpg_narrative/return_of_serenity/app/storyline_day_one.rb
 def day_one_beginning args
   {
     background: 'sprites/side-of-home.png',
@@ -20212,9 +32948,9 @@ def explaining_the_special_power_inside_computer args
   }
 end
 
-

-Rpg Narrative - Return Of Serenity - storyline_final_decision.rb
-# ./samples/99_genre_rpg_narrative/return_of_serenity/app/storyline_final_decision.rb
+
+Rpg Narrative - Return Of Serenity - storyline_final_decision.rb
+# ./samples/99_genre_rpg_narrative/return_of_serenity/app/storyline_final_decision.rb
 def final_decision_side_of_home args
   {
     fade: 120,
@@ -20352,9 +33088,9 @@ def final_decision_ship_status_shared args
   ]
 end
 
-

-Rpg Narrative - Return Of Serenity - storyline_final_message.rb
-# ./samples/99_genre_rpg_narrative/return_of_serenity/app/storyline_final_message.rb
+
+Rpg Narrative - Return Of Serenity - storyline_final_message.rb
+# ./samples/99_genre_rpg_narrative/return_of_serenity/app/storyline_final_message.rb
 def final_message_sad args
   {
     fade: 60,
@@ -20572,9 +33308,9 @@ def final_message_summary args
   end
 end
 
-

-Rpg Narrative - Return Of Serenity - storyline_serenity_alive.rb
-# ./samples/99_genre_rpg_narrative/return_of_serenity/app/storyline_serenity_alive.rb
+
+Rpg Narrative - Return Of Serenity - storyline_serenity_alive.rb
+# ./samples/99_genre_rpg_narrative/return_of_serenity/app/storyline_serenity_alive.rb
 def serenity_alive_side_of_home args
   {
     fade: 60,
@@ -20795,9 +33531,9 @@ def serenity_alive_current_message args
   end
 end
 
-

-Rpg Narrative - Return Of Serenity - storyline_serenity_bio.rb
-# ./samples/99_genre_rpg_narrative/return_of_serenity/app/storyline_serenity_bio.rb
+
+Rpg Narrative - Return Of Serenity - storyline_serenity_bio.rb
+# ./samples/99_genre_rpg_narrative/return_of_serenity/app/storyline_serenity_bio.rb
 def serenity_bio_infront_of_home args
   {
     fade: 60,
@@ -20950,9 +33686,9 @@ def bad_dream_last_reply args
   end
 end
 
-

-Rpg Narrative - Return Of Serenity - storyline_serenity_introduction.rb
-# ./samples/99_genre_rpg_narrative/return_of_serenity/app/storyline_serenity_introduction.rb
+
+Rpg Narrative - Return Of Serenity - storyline_serenity_introduction.rb
+# ./samples/99_genre_rpg_narrative/return_of_serenity/app/storyline_serenity_introduction.rb
 # decision_graph "Message from Sasha",
 #                "I should reply.",
 #                [:replied_to_introduction_seriously,  "Reply Seriously", "Who is this?"],
@@ -21049,9 +33785,9 @@ def replied_to_introduction_side_of_home args
   }
 end
 
-

-Rpg Narrative - Return Of Serenity - storyline_speed_of_light.rb
-# ./samples/99_genre_rpg_narrative/return_of_serenity/app/storyline_speed_of_light.rb
+
+Rpg Narrative - Return Of Serenity - storyline_speed_of_light.rb
+# ./samples/99_genre_rpg_narrative/return_of_serenity/app/storyline_speed_of_light.rb
 def speed_of_light_front_of_home args
   {
     background: 'sprites/front-of-home.png',
@@ -21157,9 +33893,9 @@ def speed_of_light_end_of_day args
   }
 end
 
-

-Rpg Roguelike - Roguelike Line Of Sight - constants.rb
-# ./samples/99_genre_rpg_roguelike/roguelike_line_of_sight/app/constants.rb
+
+Rpg Roguelike - Roguelike Starting Point - constants.rb
+# ./samples/99_genre_rpg_roguelike/01_roguelike_starting_point/app/constants.rb
 SHOW_LEGEND = true
 SOURCE_TILE_SIZE = 16
 DESTINATION_TILE_SIZE = 16
@@ -21169,9 +33905,9 @@ TILE_G = 0
 TILE_B = 0
 TILE_A = 255
 
-

-Rpg Roguelike - Roguelike Line Of Sight - legend.rb
-# ./samples/99_genre_rpg_roguelike/roguelike_line_of_sight/app/legend.rb
+
+Rpg Roguelike - Roguelike Starting Point - legend.rb
+# ./samples/99_genre_rpg_roguelike/01_roguelike_starting_point/app/legend.rb
 def tick_legend args
   return unless SHOW_LEGEND
 
@@ -21238,9 +33974,9 @@ def tick_legend args
   end
 end
 
-

-Rpg Roguelike - Roguelike Line Of Sight - main.rb
-# ./samples/99_genre_rpg_roguelike/roguelike_line_of_sight/app/main.rb
+
+Rpg Roguelike - Roguelike Starting Point - main.rb
+# ./samples/99_genre_rpg_roguelike/01_roguelike_starting_point/app/main.rb
 require 'app/constants.rb'
 require 'app/sprite_lookup.rb'
 require 'app/legend.rb'
@@ -21339,9 +34075,9 @@ def tile_in_game x, y, tile_key
        tile_key)
 end
 
-

-Rpg Roguelike - Roguelike Line Of Sight - sprite_lookup.rb
-# ./samples/99_genre_rpg_roguelike/roguelike_line_of_sight/app/sprite_lookup.rb
+
+Rpg Roguelike - Roguelike Starting Point - sprite_lookup.rb
+# ./samples/99_genre_rpg_roguelike/01_roguelike_starting_point/app/sprite_lookup.rb
 def sprite_lookup
   {
     0 => [3, 0],
@@ -21467,9 +34203,9 @@ end
 
 $gtk.args.state.reserved.sprite_lookup = sprite_lookup
 
-

-Rpg Roguelike - Roguelike Starting Point - main.rb
-# ./samples/99_genre_rpg_roguelike/roguelike_starting_point/app/main.rb
+
+Rpg Roguelike - Roguelike Line Of Sight - main.rb
+# ./samples/99_genre_rpg_roguelike/02_roguelike_line_of_sight/app/main.rb
 =begin
 
  APIs listing that haven't been encountered in previous sample apps:
@@ -21910,9 +34646,9 @@ def tick args
   $game.tick
 end
 
-

-Rpg Tactical - Hexagonal Grid - main.rb
-# ./samples/99_genre_rpg_tactical/hexagonal_grid/app/main.rb
+
+Rpg Tactical - Hexagonal Grid - main.rb
+# ./samples/99_genre_rpg_tactical/hexagonal_grid/app/main.rb
 class HexagonTileGame
   attr_gtk
 
@@ -21982,9 +34718,9 @@ end
 
 $gtk.reset
 
-

-Rpg Tactical - Isometric Grid - main.rb
-# ./samples/99_genre_rpg_tactical/isometric_grid/app/main.rb
+
+Rpg Tactical - Isometric Grid - main.rb
+# ./samples/99_genre_rpg_tactical/isometric_grid/app/main.rb
 class Isometric
     attr_accessor :grid, :inputs, :state, :outputs
 
@@ -22248,9 +34984,9 @@ def tick args
     $isometric.tick
 end
 
-

-Rpg Topdown - Topdown Starting Point - main.rb
-# ./samples/99_genre_rpg_topdown/topdown_starting_point/app/main.rb
+
+Rpg Topdown - Topdown Starting Point - main.rb
+# ./samples/99_genre_rpg_topdown/topdown_starting_point/app/main.rb
 =begin
 
  APIs listing that haven't been encountered in previous sample apps:
@@ -22360,9 +35096,13 @@ def move_player args, *vector
                     vector.y * args.state.player_speed) # the box will move extremely slow
 end
 
-

-args.rb
-# ./dragon/args.rb
+
+OSS
+
+Follows is a source code listing for all files that have been open sourced. This code can be found online at https://github.com/DragonRuby/dragonruby-game-toolkit-contrib/.
+
+args.rb
+# ./dragon/args.rb
 # coding: utf-8
 # Copyright 2019 DragonRuby LLC
 # MIT License
@@ -22406,6 +35146,8 @@ module GTK
     # @return [Geometry]
     attr_accessor :geometry
 
+    attr_accessor :fn
+
     # This is where you'll put state associated with your video game.
     #
     # @return [OpenEntity]
@@ -22423,6 +35165,10 @@ module GTK
 
     attr_accessor :layout
 
+    attr_accessor :easing
+
+    attr_accessor :string
+
     def initialize runtime, recording
       @inputs = Inputs.new
       @outputs = Outputs.new args: self
@@ -22437,8 +35183,11 @@ module GTK
       @pixel_arrays = {}
       @all_tests = []
       @geometry = GTK::Geometry
+      @fn = GTK::Fn
       @wizards = Wizards.new
       @layout = GTK::Layout.new @grid.w, @grid.h
+      @easing = GTK::Easing
+      @string = String
     end
 
 
@@ -22587,12 +35336,16 @@ module GTK
     def controller_two
       @inputs.controller_two
     end
+
+    def autocomplete_methods
+      [:inputs, :outputs, :gtk, :state, :geometry, :audio, :grid, :layout, :fn]
+    end
   end
 end
 
-

-assert.rb
-# ./dragon/assert.rb
+
+assert.rb
+# ./dragon/assert.rb
 # coding: utf-8
 # Copyright 2019 DragonRuby LLC
 # MIT License
@@ -22699,6 +35452,16 @@ end
       nil
     end
 
+    def not_equal! actual, expected, message = nil
+      @assertion_performed = true
+      if actual == expected
+        actual_string = "#{actual}#{actual.nil? ? " (nil) " : " " }".strip
+        message = "actual:\n#{actual_string}\n\nequaled\n\nexpected:\n#{expected}.\n#{message}"
+        raise message
+      end
+      nil
+    end
+
 =begin
 Assert if a value is explicitly nil (not false).
 
@@ -22722,9 +35485,9 @@ end
   end
 end
 
-

-attr_gtk.rb
-# ./dragon/attr_gtk.rb
+
+attr_gtk.rb
+# ./dragon/attr_gtk.rb
 # coding: utf-8
 # Copyright 2019 DragonRuby LLC
 # MIT License
@@ -22769,37 +35532,50 @@ module AttrGTK
   def geometry
     args.geometry
   end
+
+  def layout
+    args.layout
+  end
 end
 
-

-attr_sprite.rb
-# ./dragon/attr_sprite.rb
+
+attr_sprite.rb
+# ./dragon/attr_sprite.rb
 # Copyright 2019 DragonRuby LLC
 # MIT License
 # attr_sprite.rb has been released under MIT (*only this file*).
 
 # @private
 module AttrRect
+  include GTK::Geometry
+
   def left
-    @x
+    (@x || self.x)
   end
 
   def right
-    @x + @w
+    (@x || self.x) + (@w || self.w)
   end
 
   def bottom
-    @y
+    (@y || self.y)
   end
 
   def top
-    @y + @h
+    (@y || self.y) + (@h || self.h)
+  end
+
+  def x1
+    (@x || self.x)
+  end
+
+  def y1
+    (@y || self.y)
   end
 end
 
 module AttrSprite
   include AttrRect
-  include GTK::Geometry
 
   attr_accessor :x, :y, :w, :h, :path, :angle, :a, :r, :g, :b, :tile_x,
                 :tile_y, :tile_w, :tile_h, :flip_horizontally,
@@ -22814,26 +35590,18 @@ module AttrSprite
     self
   end
 
-  def x1
-    @x
-  end
-
   def x1= value
     @x = value
   end
 
-  def y1
-    @y
-  end
-
   def y1= value
     @y = value
   end
 end
 
-

-console.rb
-# ./dragon/console.rb
+
+console.rb
+# ./dragon/console.rb
 # Copyright 2019 DragonRuby LLC
 # MIT License
 # console.rb has been released under MIT (*only this file*).
@@ -22989,7 +35757,10 @@ module GTK
       @visible
     end
 
-    # @gtk
+    def open reason = nil
+      show reason
+    end
+
     def show reason = nil
       @shown_at = Kernel.global_tick_count
       @show_reason = reason
@@ -23272,6 +36043,10 @@ S
         if args.inputs.keyboard.key_down.control || args.inputs.keyboard.key_down.meta
           prompt << $gtk.ffi_misc.getclipboard
         end
+      elsif args.inputs.keyboard.key_down.home
+        prompt.move_cursor_home
+      elsif args.inputs.keyboard.key_down.end
+        prompt.move_cursor_end
       elsif args.inputs.keyboard.key_down.up
         if @command_history_index == -1
           @nonhistory_input = current_input_str
@@ -23290,9 +36065,17 @@ S
           self.current_input_str = @command_history[@command_history_index].dup
         end
       elsif args.inputs.keyboard.key_down.left
-        prompt.move_cursor_left
+        if args.inputs.keyboard.key_down.control
+          prompt.move_cursor_left_word
+        else
+          prompt.move_cursor_left
+        end
       elsif args.inputs.keyboard.key_down.right
-        prompt.move_cursor_right
+        if args.inputs.keyboard.key_down.control
+          prompt.move_cursor_right_word
+        else
+          prompt.move_cursor_right
+        end
       elsif inputs_scroll_up_full? args
         scroll_up_full
       elsif inputs_scroll_down_full? args
@@ -23305,8 +36088,10 @@ S
         prompt.clear
         @command_history_index = -1
         @nonhistory_input = ''
-      elsif args.inputs.keyboard.key_down.backspace || args.inputs.keyboard.key_down.delete
+      elsif args.inputs.keyboard.key_down.backspace
         prompt.backspace
+      elsif args.inputs.keyboard.key_down.delete
+        prompt.delete
       elsif args.inputs.keyboard.key_down.tab
         prompt.autocomplete
       end
@@ -23391,7 +36176,7 @@ S
     end
 
     def error_markers
-      ["exception", "error", "undefined method", "failed", "syntax", "deprecated"]
+      ["exception:", "error:", "undefined method", "failed", "syntax", "deprecated"]
     end
 
     def include_subdued_markers? text
@@ -23403,7 +36188,7 @@ S
     end
 
     def subdued_markers
-      ["reloaded", "exported the"]
+      ["reloaded", "exported the", "~require~"]
     end
 
     def calc args
@@ -23588,9 +36373,9 @@ S
   end
 end
 
-

-console_color.rb
-# ./dragon/console_color.rb
+
+console_color.rb
+# ./dragon/console_color.rb
 # Copyright 2019 DragonRuby LLC
 # MIT License
 # console_color.rb has been released under MIT (*only this file*).
@@ -23622,9 +36407,9 @@ module GTK
   end
 end
 
-

-console_font_style.rb
-# ./dragon/console_font_style.rb
+
+console_font_style.rb
+# ./dragon/console_font_style.rb
 # Copyright 2019 DragonRuby LLC
 # MIT License
 # console_font_style.rb has been released under MIT (*only this file*).
@@ -23666,9 +36451,9 @@ module GTK
   end
 end
 
-

-console_menu.rb
-# ./dragon/console_menu.rb
+
+console_menu.rb
+# ./dragon/console_menu.rb
 # Copyright 2019 DragonRuby LLC
 # MIT License
 # console_menu.rb has been released under MIT (*only this file*).
@@ -23829,9 +36614,9 @@ module GTK
   end
 end
 
-

-console_prompt.rb
-# ./dragon/console_prompt.rb
+
+console_prompt.rb
+# ./dragon/console_prompt.rb
 # Copyright 2019 DragonRuby LLC
 # MIT License
 # console_prompt.rb has been released under MIT (*only this file*).
@@ -23842,6 +36627,9 @@ end
 module GTK
   class Console
     class Prompt
+      # ? Can be changed, it was just taken from my editor settings :>
+      WORD_LIMITER_CHARS = "`~!@#$%^&*-=+()[]{}\|;:'\",.<>/?_ \t\n\0".chars
+
       attr_accessor :current_input_str, :font_style, :console_text_width, :last_input_str, :last_input_str_changed
 
       def initialize(font_style:, text_color:, console_text_width:)
@@ -23866,6 +36654,7 @@ module GTK
       def current_input_str=(str)
         @current_input_str = str
         @cursor_position = str.length
+        update_cursor_position_px
       end
 
       def <<(str)
@@ -23885,16 +36674,57 @@ module GTK
         reset_autocomplete
       end
 
+      def delete
+        return if current_input_str.length.zero? || @cursor_position == current_input_str.length
+
+        @cursor_position += 1
+        backspace
+      end
+
       def move_cursor_left
         @cursor_position -= 1 if @cursor_position > 0
         update_cursor_position_px
       end
 
+      def move_cursor_left_word
+        return if @cursor_position.zero?
+
+        new_pos = @cursor_position - 1
+        (is_word_boundary? @current_input_str[new_pos]) ?
+            (new_pos -= 1 until !(is_word_boundary? @current_input_str[new_pos - 1]) || new_pos.zero?):
+            (new_pos -= 1 until (is_word_boundary? @current_input_str[new_pos - 1]) || new_pos.zero?)
+
+        @cursor_position = new_pos
+        update_cursor_position_px
+      end
+
       def move_cursor_right
         @cursor_position += 1 if @cursor_position < current_input_str.length
         update_cursor_position_px
       end
 
+      def move_cursor_right_word
+        return if @cursor_position.equal? str_len
+
+        new_pos = @cursor_position + 1
+        (is_word_boundary? @current_input_str[new_pos]) ?
+            (new_pos += 1 until !(is_word_boundary? @current_input_str[new_pos]) || (new_pos.equal? str_len)):
+            (new_pos += 1 until (is_word_boundary? @current_input_str[new_pos]) || (new_pos.equal? str_len))
+
+        @cursor_position = new_pos
+        update_cursor_position_px
+      end
+
+      def move_cursor_home
+        @cursor_position = 0
+        update_cursor_position_px
+      end
+
+      def move_cursor_end
+        @cursor_position = str_len
+        update_cursor_position_px
+      end
+
       def clear
         @current_input_str = ''
         @cursor_position = 0
@@ -24046,13 +36876,24 @@ S
         @last_autocomplete_prefix = nil
         @next_candidate_index = 0
       end
+
+      def is_word_boundary? char
+        # Alternative method
+        # (WORD_LIMITER_CHARS - [char]).length != WORD_LIMITER_CHARS.length
+        # Production code
+        WORD_LIMITER_CHARS.include? char
+      end
+
+      def str_len
+        @current_input_str.length
+      end
     end
   end
 end
 
-

-controller.rb
-# ./dragon/controller.rb
+
+controller.rb
+# ./dragon/controller.rb
 # coding: utf-8
 # Copyright 2019 DragonRuby LLC
 # MIT License
@@ -24176,9 +37017,9 @@ module GTK
 end
 
 
-

-controller/config.rb
-# ./dragon/controller/config.rb
+
+controller/config.rb
+# ./dragon/controller/config.rb
 # coding: utf-8
 # Copyright 2019 DragonRuby LLC
 # MIT License
@@ -24579,9 +37420,9 @@ module GTK
   end
 end
 
-

-controller/keys.rb
-# ./dragon/controller/keys.rb
+
+controller/keys.rb
+# ./dragon/controller/keys.rb
 # coding: utf-8
 # Copyright 2019 DragonRuby LLC
 # MIT License
@@ -24603,7 +37444,7 @@ module GTK
       ].freeze
 
       LABELS.each do |label|
-        attr_reader label
+        attr label
       end
 
       # Activate a key.
@@ -24634,9 +37475,9 @@ module GTK
   end
 end
 
-

-directional_input_helper_methods.rb
-# ./dragon/directional_input_helper_methods.rb
+
+directional_input_helper_methods.rb
+# ./dragon/directional_input_helper_methods.rb
 # coding: utf-8
 # Copyright 2019 DragonRuby LLC
 # MIT License
@@ -24693,8 +37534,8 @@ S
     # - ~nil~ which denotes that no directional input exists.
     # - ~[   0,    1]~ which denotes that only up is being held/pressed.
     # - ~[   0,   -1]~ which denotes that only down is being held/pressed.
-    # - ~[ 0.5,  0.5]~ which denotes that right and up are being pressed/held.
-    # - ~[-0.5, -0.5]~ which denotes that left and down are being pressed/held.
+    # - ~[-0.707,  0.707]~ which denotes that right and up are being pressed/held.
+    # - ~[-0.707, -0.707]~ which denotes that left and down are being pressed/held.
     #
     # @gtk
     def directional_vector
@@ -24703,7 +37544,7 @@ S
       if lr == 0 && ud == 0
         return nil
       elsif lr.abs == ud.abs
-        return [lr.half, ud.half]
+        return [45.vector_x * lr.sign, 45.vector_y * ud.sign, ud.sign]
       else
         return [lr, ud]
       end
@@ -24730,9 +37571,9 @@ S
   end
 end
 
-

-easing.rb
-# ./dragon/easing.rb
+
+easing.rb
+# ./dragon/easing.rb
 # coding: utf-8
 # Copyright 2019 DragonRuby LLC
 # MIT License
@@ -24740,6 +37581,15 @@ end
 
 module GTK
   module Easing
+    def self.ease start_tick, current_tick, duration, *definitions
+      ease_extended start_tick,
+                    current_tick,
+                    start_tick + duration,
+                    (initial_value *definitions),
+                    (final_value *definitions),
+                    *definitions
+    end
+
     def self.ease_extended start_tick, current_tick, end_tick, default_before, default_after, *definitions
       definitions.flatten!
       definitions = [:identity] if definitions.length == 0
@@ -24754,7 +37604,12 @@ module GTK
       y
     end
 
+    def self.ease_spline start_tick, current_tick, duration, spline
+      ease_spline_extended start_tick, current_tick, start_tick + duration, spline
+    end
+
     def self.ease_spline_extended start_tick, current_tick, end_tick, spline
+      return spline[-1][-1] if current_tick >= end_tick
       duration = end_tick - start_tick
       t = (current_tick - start_tick).fdiv duration
       time_allocation_per_curve = 1.fdiv(spline.length)
@@ -24766,12 +37621,12 @@ module GTK
 
     def self.initial_value *definitions
       definitions.flatten!
-      return Easing.exec_definition (definitions.value(-1) || :identity), 0, 10, 0
+      return Easing.exec_definition (definitions.at(-1) || :identity), 0, 10, 0
     end
 
     def self.final_value *definitions
       definitions.flatten!
-      return Easing.exec_definition (definitions.value(-1) || :identity), 0, 10, 1.0
+      return Easing.exec_definition (definitions.at(-1) || :identity), 0, 10, 1.0
     end
 
     def self.exec_definition definition, start_tick, duration, x
@@ -24816,9 +37671,104 @@ end
 
 Easing = GTK::Easing
 
-

-geometry.rb
-# ./dragon/geometry.rb
+
+entity.rb
+# ./dragon/entity.rb
+# coding: utf-8
+# Copyright 2019 DragonRuby LLC
+# MIT License
+# entity.rb has been released under MIT (*only this file*).
+
+module GTK
+  class Entity
+    def self.id!
+      @id ||= 0
+      @id += 1
+      @id
+    end
+
+    def self.__reset_id__!
+      @id = 0
+    end
+
+    def self.strict_entities
+      @strict_entities ||= {}
+      @strict_entities
+    end
+
+    def self.parse_serialization_data data
+      r = Entity.parse_serialization_data data
+      return r if r.is_a? OpenEntity
+      return r if r.is_a? StrictEntity
+      raise <<-S
+* ERROR:
+The save data looks to be corrupt.
+
+S
+    end
+
+    def self.parse_serialization_data value
+      if value.is_a?(Hash) && value[:entity_id] && value[:entity_strict]
+        o = new_entity_strict value[:entity_name], value
+        o.load_entity_data! value
+        return o
+      elsif value.is_a?(Hash) && value[:entity_id]
+        o = OpenEntity.new
+        o.load_entity_data! value
+        return o
+      elsif value.is_a? Array
+        return value.map { |entry| Entity.parse_serialization_data entry }
+      else
+        return value
+      end
+    end
+
+    def self.new_entity entity_type, init_hash = nil, block = nil
+      n = OpenEntity.new(entity_type)
+      n.entity_type = entity_type
+      n.created_at = Kernel.tick_count
+      n.global_created_at = Kernel.global_tick_count
+
+      if init_hash
+        init_hash.each do |k, v|
+          n.as_hash[k] = v
+        end
+      end
+
+      block.call(n) if block
+
+      n
+    end
+
+    def self.new_entity_strict entity_type, init_hash = nil, block = nil
+      if !Entity.strict_entities[entity_type]
+        init_hash ||= { }
+
+        n = new_entity entity_type, init_hash, block
+        klass = Class.new(StrictEntity)
+
+        klass.class_eval do
+          init_hash.each do |k, v|
+            attr_accessor k
+          end
+
+          n.as_hash.each do |k, v|
+            attr_accessor k if !init_hash[k]
+          end
+        end
+
+        Entity.strict_entities[entity_type] = klass
+      end
+
+      klass = Entity.strict_entities[entity_type]
+      (klass.new entity_type, init_hash, block)
+    end
+  end
+end
+
+
+geometry.rb
+# ./dragon/geometry.rb
 # coding: utf-8
 # Copyright 2019 DragonRuby LLC
 # MIT License
@@ -24847,8 +37797,8 @@ module GTK
 
     # Returns true if a primitive's rectangle is entirely inside another primitive's rectangle.
     # @gtk
-    def inside_rect? outer
-      Geometry.inside_rect? self, outer
+    def inside_rect? outer, tolerance = 0.0
+      Geometry.inside_rect? self, outer, tolerance
     end
 
     # Returns true if a primitive's rectangle overlaps another primitive's rectangle.
@@ -24897,10 +37847,10 @@ module GTK
       Geometry.point_inside_circle? self, circle_center_point, radius
     end
 
-    def center_inside_rect other_rect
-      offset_x = (other_rect.w - w).half
-      offset_y = (other_rect.h - h).half
-      new_rect = self.shift_rect(0, 0)
+    def self.center_inside_rect rect, other_rect
+      offset_x = (other_rect.w - rect.w).half
+      offset_y = (other_rect.h - rect.h).half
+      new_rect = rect.shift_rect(0, 0)
       new_rect.x = other_rect.x + offset_x
       new_rect.y = other_rect.y + offset_y
       new_rect
@@ -24911,30 +37861,45 @@ center_inside_rect for self #{self} and other_rect #{other_rect}. Failed with ex
 S
     end
 
-    def center_inside_rect_y other_rect
-      offset_y = (other_rect.h - h).half
-      new_rect = self.shift_rect(0, 0)
-      new_rect.y = other_rect.y + offset_y
+    def center_inside_rect other_rect
+      Geometry.center_inside_rect self, other_rect
+    end
+
+    def self.center_inside_rect_x rect, other_rect
+      offset_x   = (other_rect.w - rect.w).half
+      new_rect   = rect.shift_rect(0, 0)
+      new_rect.x = other_rect.x + offset_x
+      new_rect.y = other_rect.y
       new_rect
     rescue Exception => e
       raise e, <<-S
 * ERROR:
-center_inside_rect_y for self #{self} and other_rect #{other_rect}. Failed with exception #{e}.
+center_inside_rect_x for self #{self} and other_rect #{other_rect}. Failed with exception #{e}.
 S
     end
 
     def center_inside_rect_x other_rect
-      offset_x = (other_rect.w - w).half
-      new_rect = self.shift_rect(0, 0)
-      new_rect.x = other_rect.x + offset_x
+      Geometry.center_inside_rect_x self, other_rect
+    end
+
+    def self.center_inside_rect_y rect, other_rect
+      offset_y = (other_rect.h - rect.h).half
+      new_rect = rect.shift_rect(0, 0)
+      new_rect.x = other_rect.x
+      new_rect.y = other_rect.y + offset_y
       new_rect
     rescue Exception => e
       raise e, <<-S
 * ERROR:
-center_inside_rect_x for self #{self} and other_rect #{other_rect}. Failed with exception #{e}.
+center_inside_rect_y for self #{self} and other_rect #{other_rect}. Failed with exception #{e}.
 S
     end
 
+    def center_inside_rect_y other_rect
+      Geometry.center_inside_rect_y self, other_rect
+    end
+
+
     # Returns a primitive that is anchored/repositioned based off its retangle.
     # @gtk
     def anchor_rect anchor_x, anchor_y
@@ -24991,10 +37956,27 @@ S
 
     # @gtk
     def self.line_slope line, replace_infinity: nil
+      return replace_infinity if line.x2 == line.x
       (line.y2 - line.y).fdiv(line.x2 - line.x)
                         .replace_infinity(replace_infinity)
     end
 
+    def self.line_rise_run line
+      rise = (line.y2 - line.y).to_f
+      run  = (line.x2 - line.x).to_f
+      if rise.abs > run.abs && rise != 0
+        rise = rise.fdiv rise.abs
+        run = run.fdiv rise.abs
+      elsif run.abs > rise.abs && run != 0
+        rise = rise.fdiv run.abs
+        run = run.fdiv run.abs
+      else
+        rise = rise / rise.abs if rise != 0
+        run = run / run.abs if run != 0
+      end
+      return { x: run , y: rise }
+    end
+
     # @gtk
     def self.ray_test point, line
       slope = (line.y2 - line.y).fdiv(line.x2 - line.x)
@@ -25060,8 +38042,8 @@ S
       return false if rect_one.bottom + tolerance > rect_two.top - tolerance
       return true
     rescue Exception => e
-      context_help_rect_one = (rect_one.help_contract_implementation contract_intersect_rect?)[:not_implemented_methods]
-      context_help_rect_two = (rect_two.help_contract_implementation contract_intersect_rect?)[:not_implemented_methods]
+      context_help_rect_one = (rect_one.__help_contract_implementation contract_intersect_rect?)[:not_implemented_methods]
+      context_help_rect_two = (rect_two.__help_contract_implementation contract_intersect_rect?)[:not_implemented_methods]
       context_help = ""
       if context_help_rect_one && context_help_rect_one.length > 0
         context_help += <<-S
@@ -25129,11 +38111,11 @@ S
     end
 
     # @gtk
-    def self.inside_rect? inner_rect, outer_rect
-      inner_rect.x >= outer_rect.x &&
-      inner_rect.right <= outer_rect.right &&
-      inner_rect.y >= outer_rect.y &&
-      inner_rect.top <= outer_rect.top
+    def self.inside_rect? inner_rect, outer_rect, tolerance = 0.0
+      inner_rect.x     + tolerance >= outer_rect.x     - tolerance &&
+      inner_rect.right - tolerance <= outer_rect.right + tolerance &&
+      inner_rect.y     + tolerance >= outer_rect.y     - tolerance &&
+      inner_rect.top   - tolerance <= outer_rect.top   + tolerance
     rescue Exception => e
       raise e, ":inside_rect? failed for inner_rect: #{inner_rect} outer_rect: #{outer_rect}."
     end
@@ -25189,9 +38171,9 @@ S
   end # module Geometry
 end # module GTK
 
-

-grid.rb
-# ./dragon/grid.rb
+
+grid.rb
+# ./dragon/grid.rb
 # coding: utf-8
 # Copyright 2019 DragonRuby LLC
 # MIT License
@@ -25382,9 +38364,9 @@ module GTK
   end
 end
 
-

-inputs.rb
-# ./dragon/inputs.rb
+
+inputs.rb
+# ./dragon/inputs.rb
 # coding: utf-8
 # Copyright 2019 DragonRuby LLC
 # MIT License
@@ -25416,6 +38398,11 @@ module GTK
                   :q, :r, :s, :t, :u, :v, :w, :x,
                   :y, :z,
                   :shift, :control, :alt, :meta,
+                  :shift_left, :shift_right,
+                  :control_left, :control_right,
+                  :alt_left, :alt_right,
+                  :meta_left, :meta_right,
+                  :home, :end,
                   :left, :right, :up, :down, :pageup, :pagedown,
                   :char, :plus, :at, :forward_slash, :back_slash, :asterisk,
                   :less_than, :greater_than, :carat, :ampersand, :superscript_two,
@@ -25430,7 +38417,10 @@ module GTK
                         raw_key == 1073741905 ||
                         raw_key == 1073741906 ||
                         raw_key == 1073741899 ||
-                        raw_key == 1073741902
+                        raw_key == 1073741902 ||
+                        raw_key == 1073741898 ||
+                        raw_key == 1073741901 ||
+                        (raw_key >= 1073742048 && raw_key <= 1073742055) # Modifier Keys
 
       char = KeyboardKeys.char_with_shift raw_key, modifier
       names = KeyboardKeys.char_to_method char, raw_key
@@ -25474,32 +38464,32 @@ module GTK
 
     def self.char_to_method_hash
       @char_to_method ||= {
-        'A'  => [:a, :shift],
-        'B'  => [:b, :shift],
-        'C'  => [:c, :shift],
-        'D'  => [:d, :shift],
-        'E'  => [:e, :shift],
-        'F'  => [:f, :shift],
-        'G'  => [:g, :shift],
-        'H'  => [:h, :shift],
-        'I'  => [:i, :shift],
-        'J'  => [:j, :shift],
-        'K'  => [:k, :shift],
-        'L'  => [:l, :shift],
-        'M'  => [:m, :shift],
-        'N'  => [:n, :shift],
-        'O'  => [:o, :shift],
-        'P'  => [:p, :shift],
-        'Q'  => [:q, :shift],
-        'R'  => [:r, :shift],
-        'S'  => [:s, :shift],
-        'T'  => [:t, :shift],
-        'U'  => [:u, :shift],
-        'V'  => [:v, :shift],
-        'W'  => [:w, :shift],
-        'X'  => [:x, :shift],
-        'Y'  => [:y, :shift],
-        'Z'  => [:z, :shift],
+        'A'  => [:a],
+        'B'  => [:b],
+        'C'  => [:c],
+        'D'  => [:d],
+        'E'  => [:e],
+        'F'  => [:f],
+        'G'  => [:g],
+        'H'  => [:h],
+        'I'  => [:i],
+        'J'  => [:j],
+        'K'  => [:k],
+        'L'  => [:l],
+        'M'  => [:m],
+        'N'  => [:n],
+        'O'  => [:o],
+        'P'  => [:p],
+        'Q'  => [:q],
+        'R'  => [:r],
+        'S'  => [:s],
+        'T'  => [:t],
+        'U'  => [:u],
+        'V'  => [:v],
+        'W'  => [:w],
+        'X'  => [:x],
+        'Y'  => [:y],
+        'Z'  => [:z],
         "!"  => [:exclamation_point],
         "0"  => [:zero],
         "1"  => [:one],
@@ -25550,18 +38540,29 @@ module GTK
         "?"  => [:question_mark],
         '%'  => [:percent_sign],
         "º"  => [:ordinal_indicator],
+        1073741898 => [:home],
+        1073741901 => [:end],
         1073741903 => [:right],
         1073741904 => [:left],
         1073741905 => [:down],
         1073741906 => [:up],
         1073741899 => [:pageup],
         1073741902 => [:pagedown],
-        127 => [:delete]
+        127 => [:delete],
+        1073742049 => [:shift_left, :shift],
+        1073742053 => [:shift_right, :shift],
+        1073742048 => [:control_left, :control],
+        1073742052 => [:control_right, :control],
+        1073742050 => [:alt_left, :alt],
+        1073742054 => [:alt_right, :alt],
+        1073742051 => [:meta_left, :meta],
+        1073742055 => [:meta_right, :meta]
       }
     end
 
     def self.char_to_method char, int = nil
-      char_to_method_hash[char] || char_to_method_hash[int] || [char.to_sym || int]
+      methods = char_to_method_hash[char] || char_to_method_hash[int]
+      methods ? methods.dup : [char.to_sym || int]
     end
 
     def clear
@@ -25893,6 +38894,10 @@ module GTK
       point.point_inside_circle? center, radius
     end
 
+    def intersect_rect? other_rect
+      { x: point.x, y: point.y, w: 0, h: 0 }.intersect_rect? other_rect
+    end
+
     alias_method :position, :point
 
     def clear
@@ -25950,14 +38955,20 @@ module GTK
     attr_accessor :moved,
                   :moved_at,
                   :global_moved_at,
+                  :down_at,
+                  :global_down_at,
                   :touch_order,
+                  :first_tick_down,
                   :x, :y
 
     def initialize
       @moved = false
       @moved_at = 0
       @global_moved_at = 0
+      @down_at = 0
+      @global_down_at = 0
       @touch_order = 0
+      @first_tick_down = true
       @x = 0
       @y = 0
     end
@@ -25983,6 +38994,9 @@ module GTK
       result[:touch_order] = @touch_order
       result[:moved] = @moved
       result[:moved_at] = @moved_at
+      result[:global_moved_at] = @global_moved_at
+      result[:down_at] = @down_at
+      result[:global_down_at] = @global_down_at
 
       result
     end
@@ -26013,6 +39027,10 @@ module GTK
     # @gtk
     attr_reader :mouse
 
+    # @return [HTTPRequest[]]
+    # @gtk
+    attr_accessor :http_requests
+
     # @return {FingerTouch}
     # @gtk
     attr_reader :touch
@@ -26029,6 +39047,7 @@ module GTK
       @finger_one = nil
       @finger_two = nil
       @text = []
+      @http_requests = []
     end
 
     def up
@@ -26104,6 +39123,7 @@ module GTK
       @keyboard.clear
       @controllers.each(&:clear)
       @touch.clear
+      @http_requests.clear
       @finger_one = nil
       @finger_two = nil
     end
@@ -26121,9 +39141,9 @@ module GTK
   end
 end
 
-

-ios_wizard.rb
-# ./dragon/ios_wizard.rb
+
+ios_wizard.rb
+# ./dragon/ios_wizard.rb
 # Copyright 2019 DragonRuby LLC
 # MIT License
 # ios_wizard.rb has been released under MIT (*only this file*).
@@ -26146,21 +39166,49 @@ class IOSWizard
   end
 
   def steps
+    @steps ||= []
+  end
+
+  def steps_development_build
     [
       :check_for_xcode,
       :check_for_brew,
       :check_for_certs,
       :check_for_device,
       :check_for_dev_profile,
+      :determine_team_identifier,
+      :determine_app_name,
+      :determine_app_id,
+      :blow_away_temp,
+      :stage_app,
+      :development_write_info_plist,
+      :write_entitlements_plist,
+      :compile_icons,
+      :create_payload_directory,
+      :code_sign_payload,
+      :create_ipa,
+      :deploy
+    ]
+  end
+
+  def steps_production_build
+    [
+      :check_for_xcode,
+      :check_for_brew,
+      :check_for_certs,
+      :check_for_distribution_profile,
+      :determine_team_identifier,
       :determine_app_name,
       :determine_app_id,
       :blow_away_temp,
       :stage_app,
-      :write_info_plist,
+      :production_write_info_plist,
       :write_entitlements_plist,
-      :code_sign,
+      :compile_icons,
+      :create_payload_directory,
+      :code_sign_payload,
       :create_ipa,
-      :deploy,
+      :print_publish_help
     ]
   end
 
@@ -26179,36 +39227,45 @@ class IOSWizard
     sprite_path
   end
 
-  def start
+  def start opts = nil
+    @opts = opts || {}
+
+    if !(@opts.is_a? Hash) || !($gtk.args.fn.eq_any? @opts[:env], :dev, :prod)
+      raise WizardException.new(
+              "* $wizards.ios.start needs to be provided an environment option.",
+              "** For development builds type: $wizards.ios.start env: :dev",
+              "** For production builds type: $wizards.ios.start env: :prod"
+            )
+    end
+
+    @production_build = (@opts[:env] == :prod)
+    @steps = steps_development_build
+    @steps = steps_production_build if @production_build
     @certificate_name = nil
     init_wizard_status
     log_info "Starting iOS Wizard so we can deploy to your device."
     @start_at = Kernel.global_tick_count
     steps.each do |m|
-      begin
-        result = (send m) || :success if @wizard_status[m][:result] != :success
-        @wizard_status[m][:result] = result
-      rescue Exception => e
-        if e.is_a? WizardException
-          $console.log.clear
-          $console.archived_log.clear
-          log "=" * $console.console_text_width
-          e.console_primitives.each do |p|
-            $console.add_primitive p
-          end
-          log "=" * $console.console_text_width
-        else
-          log_error "Step #{m} failed."
-          log_error e.to_s
-        end
-
-        $console.set_command "$wizards.ios.start"
-
-        break
+      log_info "Running step ~:#{m}~."
+      result = (send m) || :success if @wizard_status[m][:result] != :success
+      @wizard_status[m][:result] = result
+      log_info "Running step ~:#{m}~ complete."
+    end
+    nil
+  rescue Exception => e
+    if e.is_a? WizardException
+      $console.log.clear
+      $console.archived_log.clear
+      log "=" * $console.console_text_width
+      e.console_primitives.each do |p|
+        $console.add_primitive p
       end
+      log "=" * $console.console_text_width
+    else
+      log_error e.to_s
     end
 
-    return nil
+    $console.set_command "$wizards.ios.start env: :#{@opts[:env]}"
   end
 
   def always_fail
@@ -26265,8 +39322,31 @@ class IOSWizard
     start
   end
 
+  def check_for_distribution_profile
+    @provisioning_profile_path = "profiles/distribution.mobileprovision"
+    if !($gtk.read_file @provisioning_profile_path)
+      $gtk.system "mkdir -p #{relative_path}/profiles"
+      $gtk.system "open #{relative_path}/profiles"
+      $gtk.system "echo Download the mobile provisioning profile and place it here with the name distribution.mobileprovision > #{relative_path}/profiles/README.txt"
+      raise WizardException.new(
+        "* I didn't find a mobile provision.",
+        "** 1. Go to http://developer.apple.com and click \"Certificates, IDs & Profiles\".",
+        "** 2. Add an App Identifier.",
+        "** 3. Select the App IDs option from the list.",
+        { w: 700, h: 75, path: get_reserved_sprite("identifiers.png") },
+        "** 4. Add your Device next. You can use idevice_id -l to get the UUID of your device.",
+        { w: 365, h: 69, path: get_reserved_sprite("device-link.png") },
+        "** 5. Create a Profile. Associate your certs, id, and device.",
+        { w: 300, h: 122, path: get_reserved_sprite("profiles.png") },
+        "** 6. Download the mobile provision and save it to 'profiles/development.mobileprovision'.",
+        { w: 200, h: 124, path: get_reserved_sprite("profiles-folder.png") },
+      )
+    end
+  end
+
   def check_for_dev_profile
-    if !($gtk.read_file 'profiles/development.mobileprovision')
+    @provisioning_profile_path = "profiles/development.mobileprovision"
+    if !($gtk.read_file @provisioning_profile_path)
       $gtk.system "mkdir -p #{relative_path}/profiles"
       $gtk.system "open #{relative_path}/profiles"
       $gtk.system "echo Download the mobile provisioning profile and place it here with the name development.mobileprovision > #{relative_path}/profiles/README.txt"
@@ -26286,13 +39366,23 @@ class IOSWizard
     end
   end
 
+  def provisioning_profile_path environment
+    return "profiles/distribution.mobileprovision" if environment == :prod
+    return "profiles/development.mobileprovision"
+  end
+
+  def determine_team_identifier
+    @team_name = (team_identifier_from_provisioning_profile @opts[:env])
+    log_info "Team Identifer is: #{@team_name}"
+  end
+
   def determine_app_name
-    @app_name = dev_profile_xml[:children].first[:children].first[:children][1][:children].first[:data]
+    @app_name = (provisioning_profile_xml @opts[:env])[:children].first[:children].first[:children][1][:children].first[:data]
     log_info "App name is: #{@app_name}."
   end
 
-  def dev_profile_xml
-    xml = $gtk.read_file 'profiles/development.mobileprovision'
+  def provisioning_profile_xml environment
+    xml = $gtk.read_file (provisioning_profile_path environment)
     scrubbed = xml.each_line.map do |l|
       if l.strip.start_with? "<"
         if l.start_with? ''
@@ -26311,9 +39401,36 @@ class IOSWizard
     $gtk.parse_xml scrubbed
   end
 
+  def app_id_from_provisioning_profile environment
+    application_identifier_index = (provisioning_profile_xml environment)[:children][0][:children][0][:children][13][:children][0][:children][0][:data]
+    (provisioning_profile_xml environment)[:children][0][:children][0][:children][13][:children].each.with_index do |node, i|
+      if node[:children] && node[:children][0] && node[:children][0][:data] == "application-identifier"
+        application_identifier_index = i
+        break
+      end
+    end
+
+    app_id_with_team_identifier = (provisioning_profile_xml environment)[:children].first[:children].first[:children][13][:children][application_identifier_index + 1][:children].first[:data]
+    team_identifer = team_identifier_from_provisioning_profile environment
+    app_id_with_team_identifier.gsub "#{team_identifer}.", ""
+  end
+
+  def team_identifier_from_provisioning_profile environment
+    team_identifer_index = (provisioning_profile_xml environment)[:children][0][:children][0][:children][13][:children][0][:children][0][:data]
+
+    (provisioning_profile_xml environment)[:children][0][:children][0][:children][13][:children].each.with_index do |node, i|
+      if node[:children] && node[:children][0] && node[:children][0][:data] == "com.apple.developer.team-identifier"
+        team_identifer_index = i
+        break
+      end
+    end
+
+    (provisioning_profile_xml environment)[:children].first[:children].first[:children][13][:children][team_identifer_index + 1][:children].first[:data]
+  end
+
   def determine_app_id
-    # lol
-    @app_id = dev_profile_xml[:children].first[:children].first[:children][13][:children][1][:children].first[:data]
+    @app_id = app_id_from_provisioning_profile @opts[:env]
+
     log_info "App Identifier is set to : #{@app_id}"
   end
 
@@ -26327,7 +39444,7 @@ class IOSWizard
       log_error "I couldn't find a development profile at #{path}."
       ask_for_dev_profile
     else
-      @dev_profile_path = path
+      @provisioning_profile_path = path
       start
     end
   end
@@ -26394,8 +39511,12 @@ class IOSWizard
       raise "You do not have any Apple development certs on this computer."
     end
 
-    @certificate_name = valid_certs.first[:name]
-    log_info "I will be using '#{@certificate_name}' to deploy to your device."
+    if @production_build
+      @certificate_name = valid_certs.find_all { |f| f[:name].include? "Distribution" }.first[:name]
+    else
+      @certificate_name = valid_certs.find_all { |f| f[:name].include? "Development" }.first[:name]
+    end
+    log_info "I will be using Certificate: '#{@certificate_name}'."
   end
 
   def idevice_id_cli_app
@@ -26412,7 +39533,7 @@ class IOSWizard
 
   def valid_certs
     certs = sh("#{security_cli_app} -q find-identity -p codesigning -v").each_line.map do |l|
-      if l.include?(")") && !l.include?("Developer ID") && l.include?("Development")
+      if l.include?(")") && !l.include?("Developer ID") && (l.include?("Development") || l.include?("Distribution"))
         l.strip
       else
         nil
@@ -26439,22 +39560,37 @@ class IOSWizard
   end
 
   def write_entitlements_plist
-    entitlement_plist_string = <<-XML
+    if @production_build
+      entitlement_plist_string = <<-XML
+
+
+
+        
+                application-identifier
+                :app_id
+                beta-reports-active
+                
+        
+
+XML
+    else
+      entitlement_plist_string = <<-XML
 
 
 
-	
-		application-identifier
-		:app_id
-		get-task-allow
-		
-	
+        
+                application-identifier
+                :app_id
+                get-task-allow
+                
+        
 
 XML
+    end
 
     log_info "Creating Entitlements.plist"
 
-    $gtk.write_file_root "tmp/ios/Entitlements.plist", entitlement_plist_string.gsub(":app_id", @app_id).strip
+    $gtk.write_file_root "tmp/ios/Entitlements.plist", entitlement_plist_string.gsub(":app_id", "#{@team_name}.#{@app_id}").strip
 
     sh "/usr/bin/plutil -convert binary1 \"#{tmp_directory}/Entitlements.plist\""
     sh "/usr/bin/plutil -convert xml1 \"#{tmp_directory}/Entitlements.plist\""
@@ -26462,19 +39598,130 @@ XML
     @entitlement_plist_written = true
   end
 
-  def code_sign
-    sh "cp #{@dev_profile_path} \"#{app_path}/embedded.mobileprovision\""
-
+  def code_sign_payload
     log_info "Signing app with #{@certificate_name}."
 
-    sh "/usr/bin/plutil -convert binary1 \"#{app_path}/Info.plist\""
-
-    sh "CODESIGN_ALLOCATE=\"/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/codesign_allocate\" /usr/bin/codesign -f -s \"#{@certificate_name}\" --entitlements #{tmp_directory}/Entitlements.plist \"#{tmp_directory}/#{@app_name}.app\""
+    sh "CODESIGN_ALLOCATE=\"/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/codesign_allocate\" /usr/bin/codesign -f -s \"#{@certificate_name}\" --entitlements #{tmp_directory}/Entitlements.plist \"#{tmp_directory}/ipa_root/Payload/#{@app_name}.app\""
+    sh "CODESIGN_ALLOCATE=\"/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/codesign_allocate\" /usr/bin/codesign -f -s \"#{@certificate_name}\" --entitlements #{tmp_directory}/Entitlements.plist \"#{tmp_directory}/ipa_root/Payload/#{@app_name}.app/Runtime\""
 
     @code_sign_completed = true
   end
 
-  def write_info_plist
+  def write_info_plist_distribution
+    log_info "Adding Info.plist."
+
+    <<-XML
+
+
+
+    
+        BuildMachineOSBuild
+        20D91
+        CFBundleDevelopmentRegion
+        en
+        CFBundleName
+        :app_name
+        CFBundleDisplayName
+        A Dark Room
+        CFBundleIdentifier
+        :app_id
+        CFBundleExecutable
+        :app_name
+        CFBundleInfoDictionaryVersion
+        6.0
+        CFBundlePackageType
+        APPL
+        CFBundleShortVersionString
+        5.6
+        CFBundleSignature
+        ????
+        CFBundleVersion
+        5.6
+        CFBundleIcons
+        
+            CFBundlePrimaryIcon
+            
+                CFBundleIconName
+                AppIcon
+                CFBundleIconFiles
+                
+                    AppIcon60x60
+                
+            
+        
+        CFBundleIcons~ipad
+        
+            CFBundlePrimaryIcon
+            
+                CFBundleIconName
+                AppIcon
+                CFBundleIconFiles
+                
+                    AppIcon60x60
+                    AppIcon76x76
+                    AppIcon83.5x83.5
+                
+            
+        
+        UILaunchStoryboardName
+        SimpleSplash
+        UIRequiresFullScreen
+        
+        ITSAppUsesNonExemptEncryption
+        
+        UIRequiredDeviceCapabilities
+        
+            arm64
+        
+        MinimumOSVersion
+        10.3
+        CFBundleSupportedPlatforms
+        
+            iPhoneOS
+        
+        CFBundleIconFiles
+        
+            AppIcon20x20
+            AppIcon29x29
+            AppIcon40x40
+            AppIcon60x60
+        
+        UIDeviceFamily
+        
+            1
+            2
+        
+        UISupportedInterfaceOrientations
+        
+            UIInterfaceOrientationPortrait
+        
+        UIStatusBarStyle
+        UIStatusBarStyleDefault
+        UIBackgroundModes
+        
+        
+        DTXcode
+        0124
+        DTXcodeBuild
+        12D4e
+        DTSDKName
+        iphoneos14.4
+        DTSDKBuild
+        18D46
+        DTPlatformName
+        iphoneos
+        DTCompiler
+        com.apple.compilers.llvm.clang.1_0
+        DTPlatformVersion
+        14.4
+        DTPlatformBuild
+        18D46
+    
+
+XML
+  end
+
+  def development_write_info_plist
     log_info "Adding Info.plist."
 
     info_plist_string = <<-XML
@@ -26497,165 +39744,289 @@ XML
                         
                 
         
-	BuildMachineOSBuild
-	19C57
-	CFBundleDevelopmentRegion
-	en
-	CFBundleDisplayName
-	:app_name
-	CFBundleExecutable
-	Runtime
-	CFBundleIconFiles
-	
-		AppIcon60x60
-	
-	CFBundleIcons
-	
-		CFBundlePrimaryIcon
-		
-			CFBundleIconFiles
-			
-				AppIcon60x60
-			
-			CFBundleIconName
-			AppIcon
-		
-	
-	CFBundleIcons~ipad
-	
-		CFBundlePrimaryIcon
-		
-			CFBundleIconFiles
-			
-				AppIcon60x60
-				AppIcon76x76
-			
-			CFBundleIconName
-			AppIcon
-		
-	
-	CFBundleIdentifier
-	com.carlile.swisscheese
-	CFBundleInfoDictionaryVersion
-	6.0
-	CFBundleName
-	:app_name
-	CFBundlePackageType
-	APPL
-	CFBundleShortVersionString
-	1.0
-	CFBundleSignature
-	????
-	CFBundleSupportedPlatforms
-	
-		iPhoneOS
-	
-	CFBundleVersion
-	1.0
-	DTCompiler
-	com.apple.compilers.llvm.clang.1_0
-	DTPlatformBuild
-	17B102
-	DTPlatformName
-	iphoneos
-	DTPlatformVersion
-	13.2
-	DTSDKBuild
-	17B102
-	DTSDKName
-	iphoneos13.2
-	DTXcode
-	01131
-	DTXcodeBuild
-	11C505
-	ITSAppUsesNonExemptEncryption
-	
-	MinimumOSVersion
-	11.0
-	UIAppFonts
-	
-	UIBackgroundModes
-	
-	UIDeviceFamily
-	
-		1
-		2
-	
-	UILaunchImages
-	
-		
-			UILaunchImageMinimumOSVersion
-			11.0
-			UILaunchImageName
-			LaunchImage-1100-Portrait-2436h
-			UILaunchImageOrientation
-			Portrait
-			UILaunchImageSize
-			{375, 812}
-		
-		
-			UILaunchImageMinimumOSVersion
-			8.0
-			UILaunchImageName
-			LaunchImage-800-Portrait-736h
-			UILaunchImageOrientation
-			Portrait
-			UILaunchImageSize
-			{414, 736}
-		
-		
-			UILaunchImageMinimumOSVersion
-			8.0
-			UILaunchImageName
-			LaunchImage-800-667h
-			UILaunchImageOrientation
-			Portrait
-			UILaunchImageSize
-			{375, 667}
-		
-		
-			UILaunchImageMinimumOSVersion
-			7.0
-			UILaunchImageName
-			LaunchImage-700
-			UILaunchImageOrientation
-			Portrait
-			UILaunchImageSize
-			{320, 480}
-		
-		
-			UILaunchImageMinimumOSVersion
-			7.0
-			UILaunchImageName
-			LaunchImage-700-568h
-			UILaunchImageOrientation
-			Portrait
-			UILaunchImageSize
-			{320, 568}
-		
-		
-			UILaunchImageMinimumOSVersion
-			7.0
-			UILaunchImageName
-			LaunchImage-700-Portrait
-			UILaunchImageOrientation
-			Portrait
-			UILaunchImageSize
-			{768, 1024}
-		
-	
-	UIRequiredDeviceCapabilities
-	
-		arm64
-	
-	UIRequiresFullScreen
-	
-	UIStatusBarStyle
-	UIStatusBarStyleDefault
-	UISupportedInterfaceOrientations
-	
-		#{device_orientation_xml}
-	
+        BuildMachineOSBuild
+        20D91
+        CFBundleDevelopmentRegion
+        en
+        CFBundleDisplayName
+        :app_name
+        CFBundleExecutable
+        Runtime
+        CFBundleIconFiles
+        
+                AppIcon60x60
+        
+        CFBundleIcons
+        
+                CFBundlePrimaryIcon
+                
+                        CFBundleIconFiles
+                        
+                                AppIcon60x60
+                        
+                        CFBundleIconName
+                        AppIcon
+                
+        
+        CFBundleIcons~ipad
+        
+                CFBundlePrimaryIcon
+                
+                        CFBundleIconFiles
+                        
+                                AppIcon60x60
+                                AppIcon76x76
+                                AppIcon83.5x83.5
+                        
+                        CFBundleIconName
+                        AppIcon
+                
+        
+        CFBundleIdentifier
+        :app_id
+        CFBundleInfoDictionaryVersion
+        6.0
+        CFBundleName
+        :app_name
+        CFBundlePackageType
+        APPL
+        CFBundleShortVersionString
+        5.2
+        CFBundleSignature
+        ????
+        CFBundleSupportedPlatforms
+        
+                iPhoneOS
+        
+        CFBundleVersion
+        5.2
+        DTCompiler
+        com.apple.compilers.llvm.clang.1_0
+        DTPlatformBuild
+        18D46
+        DTPlatformName
+        iphoneos
+        DTPlatformVersion
+        14.4
+        DTSDKBuild
+        18D46
+        DTSDKName
+        iphoneos14.4
+        DTXcode
+        0124
+        DTXcodeBuild
+        12D4e
+        MinimumOSVersion
+        14.4
+        UIAppFonts
+        
+        UIBackgroundModes
+        
+        UIDeviceFamily
+        
+                1
+                2
+        
+        UILaunchImages
+        
+                
+                        UILaunchImageMinimumOSVersion
+                        7.0
+                        UILaunchImageName
+                        Default-568h@2x
+                        UILaunchImageOrientation
+                        Portrait
+                        UILaunchImageSize
+                        {320, 568}
+                
+                
+                        UILaunchImageMinimumOSVersion
+                        7.0
+                        UILaunchImageName
+                        Default-667h@2x
+                        UILaunchImageOrientation
+                        Portrait
+                        UILaunchImageSize
+                        {375, 667}
+                
+                
+                        UILaunchImageMinimumOSVersion
+                        7.0
+                        UILaunchImageName
+                        Default-736h@3x
+                        UILaunchImageOrientation
+                        Portrait
+                        UILaunchImageSize
+                        {414, 736}
+                
+        
+        UILaunchStoryboardName
+        SimpleSplash
+        UIRequiredDeviceCapabilities
+        
+                arm64
+        
+        UIRequiresFullScreen
+        
+        UIStatusBarStyle
+        UIStatusBarStyleDefault
+        UISupportedInterfaceOrientations
+        
+                UIInterfaceOrientationLandscapeRight
+        
+
+
+XML
+
+    # UIInterfaceOrientationPortrait
+    # UIInterfaceOrientationLandscapeRight
+
+    info_plist_string.gsub!(":app_name", @app_name)
+    info_plist_string.gsub!(":app_id", @app_id)
+
+    $gtk.write_file_root "tmp/ios/#{@app_name}.app/Info.plist", info_plist_string.strip
+
+    @info_plist_written = true
+  end
+
+  def production_write_info_plist
+    log_info "Adding Info.plist."
+
+    info_plist_string = <<-XML
+
+
+
+
+        BuildMachineOSBuild
+        20D91
+        CFBundleDevelopmentRegion
+        en
+        CFBundleDisplayName
+        :app_name
+        CFBundleExecutable
+        Runtime
+        CFBundleIconFiles
+        
+                AppIcon60x60
+        
+        CFBundleIcons
+        
+                CFBundlePrimaryIcon
+                
+                        CFBundleIconFiles
+                        
+                                AppIcon60x60
+                        
+                        CFBundleIconName
+                        AppIcon
+                
+        
+        CFBundleIcons~ipad
+        
+                CFBundlePrimaryIcon
+                
+                        CFBundleIconFiles
+                        
+                                AppIcon60x60
+                                AppIcon76x76
+                                AppIcon83.5x83.5
+                        
+                        CFBundleIconName
+                        AppIcon
+                
+        
+        CFBundleIdentifier
+        :app_id
+        CFBundleInfoDictionaryVersion
+        6.0
+        CFBundleName
+        :app_name
+        CFBundlePackageType
+        APPL
+        CFBundleShortVersionString
+        5.2
+        CFBundleSignature
+        ????
+        CFBundleSupportedPlatforms
+        
+                iPhoneOS
+        
+        CFBundleVersion
+        5.2
+        DTCompiler
+        com.apple.compilers.llvm.clang.1_0
+        DTPlatformBuild
+        18D46
+        DTPlatformName
+        iphoneos
+        DTPlatformVersion
+        14.4
+        DTSDKBuild
+        18D46
+        DTSDKName
+        iphoneos14.4
+        DTXcode
+        0124
+        DTXcodeBuild
+        12D4e
+        MinimumOSVersion
+        14.4
+        UIAppFonts
+        
+        UIBackgroundModes
+        
+        UIDeviceFamily
+        
+                1
+                2
+        
+        UILaunchImages
+        
+                
+                        UILaunchImageMinimumOSVersion
+                        7.0
+                        UILaunchImageName
+                        Default-568h@2x
+                        UILaunchImageOrientation
+                        Portrait
+                        UILaunchImageSize
+                        {320, 568}
+                
+                
+                        UILaunchImageMinimumOSVersion
+                        7.0
+                        UILaunchImageName
+                        Default-667h@2x
+                        UILaunchImageOrientation
+                        Portrait
+                        UILaunchImageSize
+                        {375, 667}
+                
+                
+                        UILaunchImageMinimumOSVersion
+                        7.0
+                        UILaunchImageName
+                        Default-736h@3x
+                        UILaunchImageOrientation
+                        Portrait
+                        UILaunchImageSize
+                        {414, 736}
+                
+        
+        UILaunchStoryboardName
+        SimpleSplash
+        UIRequiredDeviceCapabilities
+        
+                arm64
+        
+        UIRequiresFullScreen
+        
+        UIStatusBarStyle
+        UIStatusBarStyleDefault
+        UISupportedInterfaceOrientations
+        
+                UIInterfaceOrientationLandscapeRight
+        
 
 
 XML
@@ -26663,7 +40034,10 @@ XML
     # UIInterfaceOrientationPortrait
     # UIInterfaceOrientationLandscapeRight
 
-    $gtk.write_file_root "tmp/ios/#{@app_name}.app/Info.plist", info_plist_string.gsub(":app_name", @app_name).strip
+    info_plist_string.gsub!(":app_name", @app_name)
+    info_plist_string.gsub!(":app_id", @app_id)
+
+    $gtk.write_file_root "tmp/ios/#{@app_name}.app/Info.plist", info_plist_string.strip
 
     @info_plist_written = true
   end
@@ -26689,7 +40063,9 @@ XML
     $gtk.write_file "app/server_ip_address.txt", $gtk.ffi_misc.get_local_ip_address.strip
   end
 
-  def create_ipa
+  def create_payload_directory
+    sh "cp #{@provisioning_profile_path} \"#{app_path}/embedded.mobileprovision\""
+    sh "/usr/bin/plutil -convert binary1 \"#{app_path}/Info.plist\""
     write_ip_address
     sh "rm \"#{@app_name}\".ipa"
     sh "rm -rf \"#{app_path}/app\""
@@ -26705,18 +40081,11 @@ XML
     sh "mkdir -p #{tmp_directory}/ipa_root/Payload"
     sh "cp -r \"#{app_path}\" \"#{tmp_directory}/ipa_root/Payload\""
     sh "chmod -R 755 \"#{tmp_directory}/ipa_root/Payload\""
+  end
+
+  def create_ipa
     do_zip
     sh "cp \"#{tmp_directory}/ipa_root/archive.zip\" \"#{tmp_directory}/#{@app_name}.ipa\""
-    sh "XCODE_DIR=\"/Applications/Xcode.app/Contents/Developer\" \"#{relative_path}/dragonruby-deploy-ios\" -d \"#{@device_id}\" \"#{tmp_directory}/#{@app_name}.ipa\""
-    cmd_result = `ps -e | grep civetweb`
-    is_civet_running = (`ps -e | grep civetweb`).strip.each_line.to_a.length > 2
-    if !is_civet_running
-      $gtk.system "cp \"#{relative_path}/civetweb\" \"#{tmp_directory}/../src_backup/civetweb\""
-      $gtk.system "open \"#{tmp_directory}/../src_backup/civetweb\" -g"
-    else
-      log "* INFO: civetweb is running already running. No need to start another instance."
-    end
-    log_info "Check your device!!"
   end
 
   def do_zip
@@ -26739,12 +40108,40 @@ SCRIPT
   end
 
   def deploy
+    sh "XCODE_DIR=\"/Applications/Xcode.app/Contents/Developer\" \"#{relative_path}/dragonruby-deploy-ios\" -d \"#{@device_id}\" \"#{tmp_directory}/#{@app_name}.ipa\""
+    log_info "Check your device!!"
+  end
+
+  def print_publish_help
+      log_info "Go to https://appstoreconnect.apple.com/apps and create an App if you haven't already done so."
+      log_info "Go to https://appleid.apple.com and create a 'Application Specific Password'."
+      log_info "To upload your app, Download Transporter from the App Store https://apps.apple.com/us/app/transporter/id1450874784?mt=12."
+      log_info "Your app is located at ./tmp/ios/#{@app_name}.ipa"
+  end
+
+  def compile_icons
+    cmd = <<-S
+"/Applications/Xcode.app/Contents/Developer/usr/bin/actool" --output-format human-readable-text \
+                                                            --notices --warnings --platform iphoneos \
+                                                            --minimum-deployment-target 10.3 \
+                                                            --target-device iphone \
+                                                            --target-device ipad  --app-icon 'AppIcon' \
+                                                            --output-partial-info-plist '#{app_path}/AssetCatalog-Info.plist' \
+                                                            --compress-pngs --compile "#{app_path}" \
+                                                            "#{app_path}/Assets.xcassets"
+S
+    sh cmd
+  end
+
+  def stage_native_libs
+    sh "cp -r \"#{root_folder}/native/\" \"#{app_path}/native/\""
+    sh "CODESIGN_ALLOCATE=\"/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/codesign_allocate\" /usr/bin/codesign -f -s \"#{@certificate_name}\" --entitlements #{tmp_directory}/Entitlements.plist \"#{tmp_directory}/#{@app_name}.app/native/ios-device/ext.dylib\""
   end
 end
 
-

-itch_wizard.rb
-# ./dragon/itch_wizard.rb
+
+itch_wizard.rb
+# ./dragon/itch_wizard.rb
 # Copyright 2019 DragonRuby LLC
 # MIT License
 # itch_wizard.rb has been released under MIT (*only this file*).
@@ -26839,7 +40236,7 @@ S
     end
 
     if metadata[:icon].start_with?("#") || !@icon
-      log "* PROPT: Please provide icon path for your game."
+      log "* PROMPT: Please provide icon path for your game."
       $console.set_command "$wizards.itch.set_icon \"icon.png\""
       return :need_icon
     end
@@ -27014,9 +40411,9 @@ S
   end
 end
 
-

-layout.rb
-# ./dragon/layout.rb
+
+layout.rb
+# ./dragon/layout.rb
 # Copyright 2019 DragonRuby LLC
 # MIT License
 # layout.rb has been released under MIT (*only this file*).
@@ -27378,6 +40775,18 @@ module GTK
         result[:h] += device.grid_area.gutter * 2
       end
 
+      result[:x] += opts[:dx] if opts[:dx]
+      result[:y] += opts[:dy] if opts[:dy]
+      result[:w] += opts[:dw] if opts[:dw]
+      result[:h] += opts[:dh] if opts[:dh]
+      result[:row] = opts[:row]
+      result[:col] = opts[:col]
+
+      if $gtk.args.grid.name == :center
+        result[:x] -= 640
+        result[:y] -= 360
+      end
+
       result
     end
 
@@ -27497,9 +40906,9 @@ module GTK
   end
 end
 
-

-log.rb
-# ./dragon/log.rb
+
+log.rb
+# ./dragon/log.rb
 # coding: utf-8
 # Copyright 2019 DragonRuby LLC
 # MIT License
@@ -27765,9 +41174,9 @@ class Object
   end
 end
 
-

-numeric.rb
-# ./dragon/numeric.rb
+
+numeric.rb
+# ./dragon/numeric.rb
 # coding: utf-8
 # Copyright 2019 DragonRuby LLC
 # MIT License
@@ -27777,8 +41186,12 @@ class Numeric
   include ValueType
   include NumericDeprecated
 
+  alias_method :gt,  :>
   alias_method :gte, :>=
+  alias_method :lt,  :<
   alias_method :lte, :<=
+  alias_method :__original_eq_eq__, :== unless Numeric.instance_methods.include? :__original_eq_eq__
+
 
   # Converts a numeric value representing seconds into frames.
   #
@@ -27798,6 +41211,23 @@ class Numeric
     clamp(0, 255).to_i
   end
 
+  def clamp_wrap min, max
+    max, min = min, max if min > max
+    return self if self >= min && self <= max
+    return min if min == max
+    if self < min
+      overflow = min - self
+      return (max - overflow).clamp_wrap min, max
+    end
+
+    if self > max
+      overflow = self - max
+      return (min + overflow).clamp_wrap min, max
+    end
+
+    return self
+  end
+
   def elapsed_time tick_count_override = nil
     (tick_count_override || Kernel.tick_count) - self
   end
@@ -28051,16 +41481,18 @@ S
     vector_y max_value
   end
 
-  # @gtk
   def mod n
     self % n
   end
 
-  # @gtk
   def mod_zero? *ns
     ns.any? { |n| mod(n) == 0 }
   end
 
+  def zmod? n
+    (self % n) == 0
+  end
+
   def mult n
     self * n
   end
@@ -28182,13 +41614,10 @@ S
     return gt other
   end
 
-  alias_method(:original_eq_eq, :==) unless Numeric.instance_methods.include?(:original_eq_eq)
   def == other
-    return true if self.original_eq_eq(other)
-    if other.is_a?(OpenEntity)
-      return self.original_eq_eq(other.entity_id)
-    end
-    return self.original_eq_eq(other)
+    return true if __original_eq_eq__ other
+    return __original_eq_eq__ other.entity_id if other.is_a? OpenEntity
+    return false
   end
 
   # @gtk
@@ -28206,6 +41635,48 @@ S
     end
   end
 
+  def each
+    unless block_given?
+      raise <<-S
+* ERROR:
+A block is required for Numeric#each.
+
+S
+    end
+
+    self.to_i.times do
+      yield
+    end
+  end
+
+  def times_with_index
+    unless block_given?
+      raise <<-S
+* ERROR:
+A block is required for Numeric#times_with_index.
+
+S
+    end
+
+    self.to_i.times.with_index do |i|
+      yield i
+    end
+  end
+
+  def each_with_index
+    unless block_given?
+      raise <<-S
+* ERROR:
+A block is required for Numeric#each_with_index.
+
+S
+    end
+
+    self.to_i.times.with_index do |i|
+      yield i
+    end
+  end
+
   # @gtk
   def map_with_index
     unless block_given?
@@ -28221,69 +41692,82 @@ S
     end
   end
 
-  def check_numeric! sender, other
-    return if other.is_a? Numeric
-
+  def __raise_arithmetic_exception__ other, m, e
     raise <<-S
 * ERROR:
-Attempted to invoke :+ on #{self} with the right hand argument of:
+Attempted to invoke :#{m} on #{self} with the right hand argument of:
 
 #{other}
 
 The object above is not a Numeric.
 
+#{e}
 S
   end
 
   def - other
     return nil unless other
-    check_numeric! :-, other
     super
+  rescue Exception => e
+    __raise_arithmetic_exception__ other, :-, e
   end
 
   def + other
     return nil unless other
-    check_numeric! :+, other
     super
+  rescue Exception => e
+    __raise_arithmetic_exception__ other, :+, e
   end
 
   def * other
     return nil unless other
-    check_numeric! :*, other
     super
+  rescue Exception => e
+    __raise_arithmetic_exception__ other, :*, e
   end
 
   def / other
     return nil unless other
-    check_numeric! :/, other
     super
+  rescue Exception => e
+    __raise_arithmetic_exception__ other, :/, e
   end
 
   def serialize
     self
   end
 
+  def self.from_top n
+    return 720 - n unless $gtk
+    $gtk.args.grid.top - n
+  end
+
   def from_top
-    return 720 - self unless $gtk
-    $gtk.args.grid.h - self
+    Numeric.from_top self
+  end
+
+  def self.from_right n
+    return 1280 - n unless $gtk
+    $gtk.args.grid.right - n
   end
 
   def from_right
-    return 1280 - self unless $gtk
-    $gtk.args.grid.w - self
+    Numeric.from_right self
+  end
+
+  def self.clamp n, min, max
+    n.clamp min, max
   end
 end
 
 class Fixnum
   include ValueType
 
-  alias_method(:original_eq_eq, :==) unless Fixnum.instance_methods.include?(:original_eq_eq)
-
-  def - other
-    return nil unless other
-    check_numeric! :-, other
-    super
-  end
+  alias_method :__original_eq_eq__,    :== unless Fixnum.instance_methods.include? :__original_eq_eq__
+  alias_method :__original_add__,      :+  unless Fixnum.instance_methods.include? :__original_add__
+  alias_method :__original_subtract__, :-  unless Fixnum.instance_methods.include? :__original_subtract__
+  alias_method :__original_multiply__, :*  unless Fixnum.instance_methods.include? :__original_multiply__
+  alias_method :__original_divide__,   :-  unless Fixnum.instance_methods.include? :__original_divide__
 
   # Returns `true` if the numeric value is evenly divisible by 2.
   #
@@ -28301,28 +41785,36 @@ class Fixnum
 
   def + other
     return nil unless other
-    check_numeric! :+, other
     super
+  rescue Exception => e
+    __raise_arithmetic_exception__ other, :+, e
   end
 
   def * other
     return nil unless other
-    check_numeric! :*, other
     super
+  rescue Exception => e
+    __raise_arithmetic_exception__ other, :*, e
   end
 
   def / other
     return nil unless other
-    check_numeric! :/, other
     super
+  rescue Exception => e
+    __raise_arithmetic_exception__ other, :/, e
+  end
+
+  def - other
+    return nil unless other
+    super
+  rescue Exception => e
+    __raise_arithmetic_exception__ other, :-, e
   end
 
   def == other
-    return true if self.original_eq_eq(other)
-    if other.is_a?(GTK::OpenEntity)
-      return self.original_eq_eq(other.entity_id)
-    end
-    return self.original_eq_eq(other)
+    return true if __original_eq_eq__ other
+    return __original_eq_eq__ other.entity_id if other.is_a? GTK::OpenEntity
+    return false
   end
 
   # Returns `-1` if the number is less than `0`. `+1` if the number
@@ -28362,33 +41854,50 @@ class Fixnum
   def sin
     Math.sin(self.to_radians)
   end
+
+  def to_sf
+    "%.2f" % self
+  end
+
+  def ifloor int
+    (self.idiv int.to_i) * int.to_i
+  end
 end
 
 class Float
   include ValueType
 
+  alias_method :__original_add__,      :+ unless Float.instance_methods.include? :__original_add__
+  alias_method :__original_subtract__, :- unless Float.instance_methods.include? :__original_subtract__
+  alias_method :__original_multiply__, :* unless Float.instance_methods.include? :__original_multiply__
+  alias_method :__original_divide__,   :- unless Float.instance_methods.include? :__original_divide__
+
   def - other
     return nil unless other
-    check_numeric! :-, other
     super
+  rescue Exception => e
+    __raise_arithmetic_exception__ other, :-, e
   end
 
   def + other
     return nil unless other
-    check_numeric! :+, other
     super
+  rescue Exception => e
+    __raise_arithmetic_exception__ other, :+, e
   end
 
   def * other
     return nil unless other
-    check_numeric! :*, other
     super
+  rescue Exception => e
+    __raise_arithmetic_exception__ other, :*, e
   end
 
   def / other
     return nil unless other
-    check_numeric! :/, other
     super
+  rescue Exception => e
+    __raise_arithmetic_exception__ other, :/, e
   end
 
   def serialize
@@ -28408,19 +41917,372 @@ class Float
     return -scalar if self < 0
     return  scalar if self > 0
   end
+
+  def to_sf
+    "%.2f" % self
+  end
+
+  def ifloor int
+    (self.idiv int.to_i) * int.to_i
+  end
 end
 
 class Integer
-  alias_method(:original_round, :round) unless Fixnum.instance_methods.include?(:original_round)
+  alias_method :__original_round__,    :round  unless Integer.instance_methods.include? :__original_round__
+  alias_method :__original_add__,      :+      unless Integer.instance_methods.include? :__original_add__
+  alias_method :__original_subtract__, :-      unless Integer.instance_methods.include? :__original_subtract__
+  alias_method :__original_multiply__, :*      unless Integer.instance_methods.include? :__original_multiply__
+  alias_method :__original_divide__,   :-      unless Integer.instance_methods.include? :__original_divide__
 
   def round *args
-    original_round
+    __original_round__
+  end
+
+  def nan?
+    false
+  end
+end
+
+
+remote_hotload_client.rb
+# ./dragon/remote_hotload_client.rb
+# coding: utf-8
+# Copyright 2019 DragonRuby LLC
+# MIT License
+# hotload_client.rb has been released under MIT (*only this file*).
+
+module GTK
+  class RemoteHotloadClient
+    attr :args
+
+    def gtk
+      args.gtk
+    end
+
+    def state
+      local_state
+    end
+
+    def initialize local_ip_address
+      local_state.local_ip_address = local_ip_address
+    end
+
+    def tick
+      return unless server_available?
+      return unless server_needed?
+
+      if should_tick? && server_needed? && !local_state.notified
+        if server_available?
+          remote_log "* REMOTE CLIENT INFO: Hotload server found at #{get_server_ip_address}:9001."
+        end
+        local_state.notified = true
+      end
+
+      tick_process_file_retrieval
+      tick_process_queue
+      tick_changes
+      tick_http_boot
+    end
+
+    def should_tick?
+      (game_state.tick_count.mod_zero? 60) && game_state.tick_count > 5.seconds
+    end
+
+    def game_state
+      args.state
+    end
+
+    def local_state
+      @local_state ||= OpenEntity.new
+      @local_state.hotload_client ||= @local_state.new_entity(:hotload_client,
+                                                              notes: "This enitity is used by DragonRuby Game Toolkit to provide you hotloading on remote machines.",
+                                                              changes: { },
+                                                              changes_queue: [],
+                                                              reloaded_files_times: [])
+      @local_state.hotload_client
+    end
+
+    def remote_log message
+      log message
+      args.gtk.http_post "http://#{get_server_ip_address}:9001/dragon/log/", { message: "=======\n#{message}\n=======\n" }, ["Content-Type: application/x-www-form-urlencoded"]
+    end
+
+    def get_server_ip_address
+      return local_state.ip_address if local_state.ip_address
+      local_state.ip_address ||= ((gtk.read_file 'app/server_ip_address.txt') || "").strip
+      local_state.ip_address
+    end
+
+    def server_available?
+      return false if gtk.platform == 'Emscripten'
+      get_server_ip_address.length != 0
+    end
+
+    def server_needed?
+      return false if gtk.platform == 'Emscripten'
+      local_state.local_ip_address != get_server_ip_address
+    end
+
+    def tick_changes
+      return unless should_tick?
+
+      local_state.greatest_tick ||= 0
+      local_state.last_greatest_tick ||= 0
+
+      tick_http_changes
+    end
+
+    def tick_http_boot
+      return if local_state.booted_at
+
+
+      if !local_state.http_boot
+        # first retrieve changes.txt which has the following format
+        # file with latest change,
+        # latest file                              update_time  key
+        # tmp/src_backup/src_backup_app_main.rb, 1597926596,  app/main.rb
+        local_state.http_boot    = args.gtk.http_get "http://#{get_server_ip_address}:9001/dragon/boot/"
+      elsif local_state.http_boot && local_state.http_boot[:http_response_code] == 200
+        local_state.last_greatest_tick = local_state.http_boot[:response_data].strip.to_i
+        local_state.greatest_tick = local_state.http_boot[:response_data].strip.to_i
+        local_state.booted_at = local_state.greatest_tick
+        remote_log '* REMOTE CLIENT INFO: HTTP GET for local_state. boot.txt succeeded.'
+        remote_log "* REMOTE CLIENT INFO: Looking for changes after: #{local_state.greatest_tick}."
+      elsif local_state.http_boot && local_state.http_boot[:http_response_code] == -1 && local_state.http_boot[:complete]
+        remote_log '* REMOTE CLIENT INFO: HTTP GET for boot.txt failed. Retrying.'
+        local_state.http_boot = nil
+      end
+    end
+
+    def tick_http_changes
+      return unless local_state.booted_at
+
+      if !local_state.http_changes
+        local_state.http_changes = args.gtk.http_get "http://#{get_server_ip_address}:9001/dragon/changes/"
+      end
+
+      if local_state.http_changes && local_state.http_changes[:http_response_code] == 200 && local_state.booted_at
+        local_state.last_greatest_tick = local_state.greatest_tick
+        # if the retrieval of changes.txt was successful
+        local_state.http_changes[:response_data].each_line do |l|
+          if l.strip.length != 0
+            # within reload state for that specific changes hash
+            # set the last time the file was updated
+            file_name, updated_at, key = l.strip.split(',')
+            file_name.strip!
+            updated_at.strip!
+            key.strip!
+            updated_at = updated_at.to_i
+            file_name = file_name.gsub("tmp/src_backup/", "")
+
+            # keep an internal clock that denotes that current time on the
+            # dev machine
+            if updated_at > local_state.greatest_tick
+              local_state.greatest_tick = updated_at
+
+              # create a new entry in change tracking for the file
+              # for every file where the file was last updated, find all the ones where the time is not the same
+              # and queue those to be retrieved and required
+              # if the last time the dev machine time was retrieved is less than the file time changed
+              # then queue the file for reload
+              current_updated_at = (local_state.changes[key] || { updated_at: 0 })[:updated_at]
+              if updated_at > current_updated_at
+                remote_log "* REMOTE CLIENT INFO: Queueing file #{file_name} for update."
+                local_state.changes[key] = { key: key,
+                                             latest_file: file_name,
+                                             updated_at: updated_at }
+                local_state.changes_queue << local_state.changes[key]
+              end
+            end
+          end
+        end
+
+        # set the greatest tick/current time of the machine
+        local_state.http_changes = nil
+      elsif local_state.http_changes && local_state.http_changes[:http_response_code] == -1 && local_state.http_change[:complete] && local_state.booted_at
+        local_state.http_changes = nil
+      end
+    end
+
+    def tick_process_queue
+      return if local_state.http_file_changes # don't pop a file off the queue if there is an http request in flight
+      return if local_state.processing_file_changes # don't pop a file if there is a file currently being processed
+      return unless local_state.changes_queue.length > 0 # return if the queue is empty
+
+      # if it isn't empty, pop the first file off the queue (FIFO)
+      local_state.processing_file_changes = local_state.changes_queue.shift
+
+      # create an http request for the file
+      url = "http://#{get_server_ip_address}:9001/dragon/#{local_state.processing_file_changes[:latest_file]}"
+      remote_log "* REMOTE CLIENT INFO: Getting new version of #{local_state.processing_file_changes[:latest_file]} (#{url})."
+      local_state.http_file_changes = args.gtk.http_get url
+    end
+
+    def tick_process_file_retrieval
+      return if !local_state.http_file_changes
+
+      # if the http request has finished successfully
+      if local_state.http_file_changes[:http_response_code] == 200
+        file_key = local_state.processing_file_changes[:key]
+        # notify that a file will be reloaded
+        remote_log "* REMOTE CLIENT INFO: Loading #{file_key}: #{local_state.processing_file_changes[:latest_file]}"
+        remote_log "#{local_state.http_file_changes[:response_data]}"
+
+        # write the latest file with what came back from the response data
+        gtk.write_file "#{file_key}", local_state.http_file_changes[:response_data]
+
+        # nil out the currently processing file so a new item can be processed from the queue
+        # local_state.reloaded_files_times << local_state.processing_file_changes[:key]
+        local_state.http_file_changes = nil
+        local_state.processing_file_changes = nil
+      end
+    end
   end
 end
 
-

-runtime/draw.rb
-# ./dragon/runtime/draw.rb
+
+runtime/autocomplete.rb
+# ./dragon/runtime/autocomplete.rb
+# Copyright 2019 DragonRuby LLC
+# MIT License
+# autocomplete.rb has been released under MIT (*only this file*).
+
+module GTK
+  class Runtime
+    module Autocomplete
+      def autocomplete_parse opts
+        if opts[:file] && !opts[:text]
+          opts[:text] = read_file opts[:file]
+        end
+
+        text  = opts[:text]
+        index = opts[:index]
+        sum   = 0
+        lines = text.each_line.to_a.map do |l|
+          sum += l.length
+          { line: l, length: l.length, sum: sum }
+        end
+        cursor_line   = lines.find { |l| l[:sum] >= index }
+        previous_line = lines.find { |l| l[:sum] < index }
+        previous_line ||= { sum: 0 }
+        if cursor_line
+          sub_index       = index - previous_line[:sum]
+          word            = (cursor_line[:line][0..sub_index - 1]).strip
+          token           = (word.split " ")[-1]
+          dots            = (token.split ".")
+          dot             = dots[-1]
+        end
+
+        {
+          text:          opts[:text],
+          file:          opts[:file],
+          index:         opts[:index],
+          cursor_line:   cursor_line,
+          previous_line: previous_line,
+          word:          word,
+          token:         token,
+          dots:          dots,
+          dot:           dot
+        }
+      end
+
+      def autocomplete_filter_methods keys, *ignores
+        ignores ||= []
+        ignores   = [ignores].flatten
+        keys   = keys.map { |k| k.to_s }
+        others = ["def", "end"] +
+                 [ :entity_keys_by_ref,
+                   :entity_name,
+                   :as_hash,
+                   :clear!,
+                   :created_at_elapsed,
+                   :entity_id,
+                   "entity_id=",
+                   "tick_count=",
+                   :global_created_at_elapsed,
+                   :load_entity_data!,
+                   :meta,
+                   :meta!,
+                   :new?,
+                   :old?,
+                   :__original_eq_eq__, :set!,
+                   :update_entity_keys_by_ref,
+                   :with_meta] +
+                 ignores + keys.find_all { |k| k.to_s.to_i.to_s == k.to_s }
+
+        final = (keys - (others.map { |m| m.to_s })).uniq
+        final
+      end
+
+      def suggest_autocompletion opts
+        parse_result = autocomplete_parse opts
+        return [] unless parse_result[:cursor_line]
+        text  = parse_result[:text]
+        word  = parse_result[:word]
+        token = parse_result[:token]
+        dots  = parse_result[:dots]
+        dot   = parse_result[:dot]
+
+        return [] if word.strip.start_with? "#"
+
+        if word[-1] == "." && token
+          lookup = {
+            'args'     => lambda { $gtk.args.autocomplete_methods },
+            'inputs'   => lambda { $gtk.args.inputs.autocomplete_methods },
+            'geometry' => lambda { $gtk.args.geometry.autocomplete_methods },
+            'outputs'  => lambda { $gtk.args.outputs.autocomplete_methods },
+            'layout'   => lambda { $gtk.args.layouts.autocomplete_methods },
+            'keyboard' => lambda { $gtk.args.keyboard.autocomplete_methods },
+            'key_down' => lambda { $gtk.args.keyboard.key_down.autocomplete_methods },
+            'key_up'   => lambda { $gtk.args.keyboard.key_up.autocomplete_methods },
+            'state'    => lambda { $gtk.args.state.autocomplete_methods },
+            'fn'       => lambda { $gtk.args.fn.autocomplete_methods },
+            '$gtk'     => lambda { $gtk.autocomplete_methods },
+            'gtk'      => lambda { $gtk.autocomplete_methods },
+            'mouse'    => lambda { $gtk.args.inputs.mouse.autocomplete_methods },
+            'click'    => lambda { [:x, :y, :point] }
+          }
+
+          lookup_result = lookup[dot]
+
+          return autocomplete_filter_methods lookup_result.call if lookup_result
+
+          start_collecting = false
+          dots_after_state = dots.find_all do |s|
+            if s == "state"
+              start_collecting = true
+              false
+            else
+              start_collecting
+            end
+          end
+
+          target = $gtk.args.state
+          dots_after_state.each do |k|
+            target = target.as_hash[k.to_sym] if target.respond_to? :as_hash
+          end
+
+          return autocomplete_filter_methods target.as_hash.keys
+        end
+
+
+        text.gsub!("[", " ")
+        text.gsub!("]", " ")
+        text.gsub!("(", " ")
+        text.gsub!(")", " ")
+        text.gsub!(":", "")
+        text.gsub!(".", " ")
+        text.gsub!("=", " ")
+        return (autocomplete_filter_methods (text.split " "),
+                                            :gtk, :false, :true, :args, :suppress_mailbox, :end)
+      end
+    end # end Autocomplete
+  end # end Runtime
+end # end GTK
+
+
+runtime/draw.rb
+# ./dragon/runtime/draw.rb
 # Copyright 2019 DragonRuby LLC
 # MIT License
 # draw.rb has been released under MIT (*only this file*).
@@ -28439,115 +42301,131 @@ module GTK
         # pass.solids.each            { |s| draw_solid s }
         # while loops are faster than each with block
         idx = 0
+        length = pass.solids.length
         while idx < pass.solids.length
-          draw_solid (pass.solids.value idx) # accessing an array using .value instead of [] is faster
+          draw_solid (pass.solids.at idx) # accessing an array using .value instead of [] is faster
           idx += 1
         end
 
         # pass.static_solids.each     { |s| draw_solid s }
         idx = 0
-        while idx < pass.static_solids.length
-          draw_solid (pass.static_solids.value idx)
+        length = pass.static_solids.length
+        while idx < length
+          draw_solid (pass.static_solids.at idx)
           idx += 1
         end
 
         # pass.sprites.each           { |s| draw_sprite s }
         idx = 0
-        while idx < pass.sprites.length
-          draw_sprite (pass.sprites.value idx)
+        length = pass.sprites.length
+        while idx < length
+          draw_sprite (pass.sprites.at idx)
           idx += 1
         end
 
         # pass.static_sprites.each    { |s| draw_sprite s }
         idx = 0
-        while idx < pass.static_sprites.length
-          draw_sprite (pass.static_sprites.value idx)
+        length = pass.static_sprites.length
+        while idx < length
+          draw_sprite (pass.static_sprites.at idx)
           idx += 1
         end
 
         # pass.primitives.each        { |p| draw_primitive p }
         idx = 0
-        while idx < pass.primitives.length
-          draw_primitive (pass.primitives.value idx)
+        length = pass.primitives.length
+        while idx < length
+          draw_primitive (pass.primitives.at idx)
           idx += 1
         end
 
         # pass.static_primitives.each { |p| draw_primitive p }
         idx = 0
-        while idx < pass.static_primitives.length
-          draw_primitive (pass.static_primitives.value idx)
+        length = pass.static_primitives.length
+        while idx < length
+          draw_primitive (pass.static_primitives.at idx)
           idx += 1
         end
 
         # pass.labels.each            { |l| draw_label l }
         idx = 0
-        while idx < pass.labels.length
-          draw_label (pass.labels.value idx)
+        length = pass.labels.length
+        while idx < length
+          draw_label (pass.labels.at idx)
           idx += 1
         end
 
         # pass.static_labels.each     { |l| draw_label l }
         idx = 0
-        while idx < pass.static_labels.length
-          draw_label (pass.static_labels.value idx)
+        length = pass.static_labels.length
+        while idx < length
+          draw_label (pass.static_labels.at idx)
           idx += 1
         end
 
         # pass.lines.each             { |l| draw_line l }
         idx = 0
-        while idx < pass.lines.length
-          draw_line (pass.lines.value idx)
+        length = pass.lines.length
+        while idx < length
+          draw_line (pass.lines.at idx)
           idx += 1
         end
 
         # pass.static_lines.each      { |l| draw_line l }
         idx = 0
+        length = pass.static_lines.length
         while idx < pass.static_lines.length
-          draw_line (pass.static_lines.value idx)
+          draw_line (pass.static_lines.at idx)
           idx += 1
         end
 
         # pass.borders.each           { |b| draw_border b }
         idx = 0
-        while idx < pass.borders.length
-          draw_border (pass.borders.value idx)
+        length = pass.borders.length
+        while idx < length
+          draw_border (pass.borders.at idx)
           idx += 1
         end
 
         # pass.static_borders.each    { |b| draw_border b }
         idx = 0
-        while idx < pass.static_borders.length
-          draw_border (pass.static_borders.value idx)
+        length = pass.static_borders.length
+        while idx < length
+          draw_border (pass.static_borders.at idx)
           idx += 1
         end
 
         if !$gtk.production
           # pass.debug.each        { |r| draw_primitive r }
           idx = 0
-          while idx < pass.debug.length
-            draw_primitive (pass.debug.value idx)
+          length = pass.debug.length
+          while idx < length
+            draw_primitive (pass.debug.at idx)
             idx += 1
           end
 
           # pass.static_debug.each { |r| draw_primitive r }
           idx = 0
-          while idx < pass.static_debug.length
-            draw_primitive (pass.static_debug.value idx)
+          length = pass.static_debug.length
+          while idx < length
+            draw_primitive (pass.static_debug.at idx)
             idx += 1
           end
         end
 
         # pass.reserved.each          { |r| draw_primitive r }
         idx = 0
-        while idx < pass.reserved.length
-          draw_primitive (pass.reserved.value idx)
+        length = pass.reserved.length
+        while idx < length
+          draw_primitive (pass.reserved.at idx)
           idx += 1
         end
 
         # pass.static_reserved.each   { |r| draw_primitive r }
         idx = 0
-        while idx < pass.static_reserved.length
-          draw_primitive (pass.static_reserved.value idx)
+        length = pass.static_reserved.length
+        while idx < length
+          draw_primitive (pass.static_reserved.at idx)
           idx += 1
         end
       rescue Exception => e
@@ -28657,16 +42535,102 @@ module GTK
   end
 end
 
-

-runtime/framerate_diagnostics.rb
-# ./dragon/runtime/framerate_diagnostics.rb
+
+runtime/framerate.rb
+# ./dragon/runtime/framerate.rb
+# Copyright 2019 DragonRuby LLC
+# MIT License
+# framerate.rb has been released under MIT (*only this file*).
+
+module GTK
+  class Runtime
+    module Framerate
+      def framerate_init
+        @tick_time = Time.new.to_i
+      end
+
+      def delta_framerate
+        (current_framerate || 0) - (@previous_framerate || 0)
+      end
+
+      def reset_framerate_calculation
+        @tick_speed_sum = 0
+        @tick_speed_count = 0
+        @previous_framerate = 0
+      end
+
+      def check_framerate
+        if @framerate_diagnostics_requested
+          log "================================"
+          log framerate_get_diagnostics
+          @framerate_diagnostics_requested = false
+        end
+
+        if !@paused
+          if @tick_time
+            @tick_speed_count += 1
+            @tick_speed_sum += Time.now.to_i - @tick_time
+            if @tick_speed_count > 60 * 2
+              if framerate_below_threshold?
+                @last_framerate = current_framerate
+                if !@console.visible?
+                  if !@framerate_important_notification_happened
+                    log_important framerate_warning_message
+                  else
+                    log framerate_warning_message
+                  end
+                  @framerate_important_notification_happened = true
+                end
+              end
+
+              @previous_framerate = current_framerate.floor
+            end
+          end
+
+          @tick_time = Time.new.to_i
+        else
+          reset_framerate_calculation
+        end
+      rescue
+        reset_framerate_calculation
+      end
+
+      def framerate_diagnostics
+        # request framerate diagnostics to be printed at the end of tick
+        @framerate_diagnostics_requested = true
+      end
+
+      def framerate_below_threshold?
+        @last_framerate ||= 60
+        current_framerate < @last_framerate &&
+          current_framerate < 50 &&
+          @previous_framerate > current_framerate &&
+          Kernel.tick_count > 600
+      end
+
+      def current_framerate
+        return 60 if !@tick_speed_sum || !@tick_speed_sum
+        r = 100.fdiv(@tick_speed_sum.fdiv(@tick_speed_count) * 100)
+        if (r.nan? || r.infinite? || r > 58)
+          r = 60
+        end
+        r || 60
+      rescue
+        60
+      end
+    end # module Framerate
+  end # end class Runtime
+end # end module GTK
+
+
+runtime/framerate_diagnostics.rb
+# ./dragon/runtime/framerate_diagnostics.rb
 # Copyright 2019 DragonRuby LLC
 # MIT License
 # framerate_diagnostics.rb has been released under MIT (*only this file*).
 
 module GTK
   class Runtime
-    # @visibility private
     module FramerateDiagnostics
       def framerate_get_diagnostics
         <<-S
@@ -28831,9 +42795,171 @@ If this warning is getting annoying put the following in your tick method:
   end
 end
 
-

-string.rb
-# ./dragon/string.rb
+
+runtime/hotload.rb
+# ./dragon/runtime/hotload.rb
+# coding: utf-8
+# Copyright 2019 DragonRuby LLC
+# MIT License
+# hotlaod.rb has been released under MIT (*only this file*).
+
+module GTK
+  class Runtime
+    # @visibility private
+    module Hotload
+      def hotload_init
+        @hotload_if_needed = 0
+        @mailbox_if_needed = 0
+        @file_mtimes = { }
+        @suppress_mailbox = true
+        files_to_reload.each { |f| init_mtimes f }
+        init_mtimes 'app/mailbox.rb'
+      end
+
+      def hotload_on_write_file file_name
+        return unless file_name.include? 'mailbox.rb'
+        @mailbox_if_needed = :force
+      end
+
+      def files_to_reload
+        if @rcb_release_mode
+          core_files_to_reload + @required_files
+        else
+          [
+            'dragon/docs.rb',
+            'dragon/help.rb',
+            'dragon/kernel_docs.rb',
+            'dragon/kernel.rb',
+            'dragon/easing.rb',
+            'dragon/top_level.rb',
+            'dragon/log.rb',
+            'dragon/geometry.rb',
+            'dragon/attr_gtk.rb',
+            'dragon/attr_sprite.rb',
+            'dragon/object.rb',
+            'dragon/class.rb',
+            'dragon/string.rb',
+            'dragon/entity.rb',
+            'dragon/strict_entity.rb',
+            'dragon/open_entity.rb',
+            'dragon/serialize.rb',
+            'dragon/primitive.rb',
+            'dragon/nil_class_false_class.rb',
+            'dragon/symbol.rb',
+            'dragon/numeric_deprecated.rb',
+            'dragon/numeric.rb',
+            'dragon/hash.rb',
+            'dragon/outputs_deprecated.rb',
+            'dragon/array_docs.rb',
+            'dragon/array.rb',
+            'dragon/outputs.rb',
+            'dragon/inputs.rb',
+            'dragon/mouse_docs.rb',
+            'dragon/recording.rb',
+            'dragon/grid.rb',
+            'dragon/layout.rb',
+            'dragon/args_deprecated.rb',
+            'dragon/fn.rb',
+            'dragon/args.rb',
+            'dragon/console_prompt.rb',
+            'dragon/console_menu.rb',
+            'dragon/console.rb',
+            'dragon/assert.rb',
+            'dragon/tests.rb',
+            'dragon/controller_config.rb',
+            'dragon/runtime/draw.rb',
+            'dragon/runtime/deprecated.rb',
+            'dragon/runtime/framerate.rb',
+            'dragon/runtime/c_bridge.rb',
+            'dragon/runtime/hotload.rb',
+            'dragon/runtime/backup.rb',
+            'dragon/runtime/async_require.rb',
+            'dragon/runtime/autocomplete.rb',
+            'dragon/api.rb',
+            'dragon/runtime.rb',
+            'dragon/trace.rb',
+            'dragon/readme_docs.rb',
+            'dragon/hotload_client.rb',
+            'dragon/ios_wizard.rb',
+            'dragon/itch_wizard.rb',
+          ] + core_files_to_reload + @required_files
+        end
+      end
+
+      def core_files_to_reload
+        [
+          'repl.rb',
+          'app/main.rb',
+          'app/repl.rb',
+          'app/tests.rb',
+          'app/test.rb',
+          'app/stdin.rb'
+        ]
+      end
+
+      def init_mtimes file
+        current_key = "current_#{file}".to_sym
+        last_key = "last_#{file}".to_sym
+        @file_mtimes[current_key] ||= @ffi_file.mtime(file)
+        @file_mtimes[last_key] ||= @ffi_file.mtime(file)
+      end
+
+      def hotload_source_files
+        @hotload_if_needed += 1
+        return unless @hotload_if_needed == 60
+        @hotload_if_needed = 0
+        files_to_reload.each { |f| reload_if_needed f }
+        console.enable
+      end
+
+      def mailbox_timeout
+        if @suppress_mailbox
+          60
+        else
+          3
+        end
+      end
+
+      def check_mailbox
+        if @mailbox_if_needed == :force # lol
+          reload_if_needed 'app/mailbox.rb', true
+          @mailbox_if_needed = 1
+          return
+        end
+        @mailbox_if_needed += 1
+        return unless @mailbox_if_needed.mod_zero? mailbox_timeout
+        @mailbox_if_needed = 1
+        reload_if_needed 'app/mailbox.rb'
+      end
+
+      def hotload_if_needed
+        hotload_source_files
+        check_mailbox
+      end
+
+      def on_load_succeeded file
+        @rcb_sender.files_reloaded << file
+        @rcb_sender.reloaded_files << file
+        Trace.untrace_classes!
+      end
+
+      def reload_if_needed file, force = false
+        current_key = "current_#{file}".to_sym
+        last_key = "last_#{file}".to_sym
+        @file_mtimes[current_key] ||= nil
+        @file_mtimes[last_key] ||= nil
+        @file_mtimes[current_key] = @ffi_file.mtime(file)
+        return if !force && @file_mtimes[last_key] == @file_mtimes[current_key]
+        on_load_succeeded file if reload_ruby_file file
+        @file_mtimes[last_key] = @file_mtimes[current_key]
+      end
+    end
+  end
+end
+
+
+string.rb
+# ./dragon/string.rb
 # coding: utf-8
 # Copyright 2019 DragonRuby LLC
 # MIT License
@@ -28842,7 +42968,7 @@ end
 class String
   include ValueType
 
-  def wrapped_lines_recur word, rest, length, aggregate
+  def self.wrapped_lines_recur word, rest, length, aggregate
     if word.nil?
       return aggregate
     elsif rest[0].nil?
@@ -28874,9 +43000,8 @@ S
     self[0..-2]
   end
 
-  # @gtk
-  def wrapped_lines length
-    self.each_line.map do |l|
+  def self.wrapped_lines string, length
+    string.each_line.map do |l|
       l = l.rstrip
       if l.length < length
         l + "\n"
@@ -28887,6 +43012,10 @@ S
     end.flatten
   end
 
+  def wrapped_lines length
+    String.wrapped_lines self, length
+  end
+
   # @gtk
   def wrap length
     wrapped_lines(length).join.rstrip
@@ -28940,9 +43069,9 @@ S
   end
 end
 
-

-tests.rb
-# ./dragon/tests.rb
+
+tests.rb
+# ./dragon/tests.rb
 # coding: utf-8
 # Copyright 2019 DragonRuby LLC
 # MIT License
@@ -29083,9 +43212,9 @@ S
   end
 end
 
-

-trace.rb
-# ./dragon/trace.rb
+
+trace.rb
+# ./dragon/trace.rb
 # coding: utf-8
 # Copyright 2019 DragonRuby LLC
 # MIT License
@@ -29271,9 +43400,9 @@ module GTK
   end
 end
 
-

-wizards.rb
-# ./dragon/wizards.rb
+
+wizards.rb
+# ./dragon/wizards.rb
 # Copyright 2019 DragonRuby LLC
 # MIT License
 # wizards.rb has been released under MIT (*only this file*).
@@ -29289,7 +43418,7 @@ module GTK
   end
 end
 
-

+

Table Of Contents

DragonRuby Game Toolkit Live Docs

Introduction

Introduction

Prerequisites

Prerequisites

The Game Loop

The Game Loop

Breakdown Of The tick Method

Breakdown Of The tick Method

Rendering A Sprite

Rendering A Sprite

Coordinate System and Virtual Canvas

Coordinate System and Virtual Canvas

Game State

Game State

There Is No Delta Time

There Is No Delta Time

Handling User Input

Handling User Input

Coding On A Raspberry Pi

Coding On A Raspberry Pi

Conclusion

Conclusion

IMPORTANT: Go through all of the sample apps! Study them thoroughly!! No really, you should definitely do this!

Guided Samples

Sample Games

Deploying To Itch.io

Creating Your Game Landing Page

Creating Your Game Landing Page

Update Your Game's Metadata

Update Your Game's Metadata

Building Your Game For Distribution

Building Your Game For Distribution

DragonRuby's Philosophy

Challenge The Status Quo

Challenge The Status Quo

Continuity of Design

Continuity of Design

Release Often And Soon

Release Early and Often

Sustainable And Ethical Monetization

Sustainable And Ethical Monetization

Sustainable And Ethical Open Source

Sustainable And Ethical Open Source

People Over Entities

People Over Entities

Building A Game Should Be Fun And Bring Happiness

Building A Game Should Be Fun And Bring Happiness

Real World Application Drives Features

Real World Application Drives Features

Frequently Asked Questions

What is DragonRuby LLP?

Frequently Asked Questions

What is DragonRuby LLP?

What is DragonRuby?

What is DragonRuby?

How is DragonRuby different than MRI?

How is DragonRuby different than MRI?

Does DragonRuby support pry or have any other debugging facilities?

Frequent Comments About Ruby as a Language Choice

But Ruby is dead.

Frequent Comments About Ruby as a Language Choice

But Ruby is dead.

But Ruby is slow.

But Ruby is slow.

Dynamic languages are slow.

Dynamic languages are slow.

Frequent Concerns

DragonRuby is not open source. That's not right.

Frequent Concerns

DragonRuby is not open source. That's not right.

DragonRuby is for pay. You should offer a free version.

DragonRuby is for pay. You should offer a free version.

But still, you should offer a free version. So I can try it out and see if I like it.

But still, you should offer a free version. So I can try it out and see if I like it.

I still think you should do a free version. Think of all people who would give it a shot.

I still think you should do a free version. Think of all people who would give it a shot.

What if I build something with DragonRuby, but DragonRuby LLP becomes insolvent.

What if I build something with DragonRuby, but DragonRuby LLP becomes insolvent.

Breakdown Of The `tick` Method

Breakdown Of The `tick` Method

Does DragonRuby support `pry` or have any other debugging facilities?

CHEATSHEET: Rendering A Label As A `Hash`

Rendering A Label As A `Hash`

CHEATSHEET: Using `args.state` To Store Your Game State

Using `args.state` To Store Your Game State

DOCS: `GTK::Runtime#write_file`

SUMMARY: `def tick args; end;`

DOCS: `GTK::Runtime#reset`

DOCS: `GTK::Runtime#calcstringbox`

`args.state`

DOCS: `Array`

`.*.entity_id`

DOCS: `Array#map`

`.*.entity_type`

`.*.created_at`

DOCS: `Array#each`

`.*.created_at_elapsed`

`.*.global_created_at`

DOCS: `Array#reject_nil`

`.*.global_created_at_elapsed`

DOCS: `Array#reject_false`

`.*.as_hash`

`.new_entity`

DOCS: `Array#product`

`.new_entity_strict`

`.tick_count`

DOCS: `Array#map_2d`

`args.inputs`

DOCS: `Array#include_any?`

`.up`

DOCS: `Array#any_intersect_rect?`

`.down`

`.left`

DOCS: `GTK::Outputs`

`.right`

DOCS: `GTK::Outputs#solids`

`.left_right`

`.up_down`

`.text` OR `.history`

`.mouse`

`.x`

`mouse.y`

`.inside_rect? rect`

DOCS: `GTK::Outputs#borders`