* 2.26
** [Pro] [Bugfix] [Android] Fixed crashes related to setting the package name with a non =org.*= prefix.
** [Bugfix] ~GTK::Runtime#serialize_state~ no longer persists data related to failed method invocations ~:__trash_count__~.
** [Bugfix] [Support] Exception is now thrown if a default value cannot be inferred for an entity's property.
** [Bugfix] Starting value for seeding ~GTK::Entity#entity_id~ is reset when ~GTK::Runtime#reset~ is invoked.
   An empty ~OpenEntity~ will not be silently created (better stacktrace/explanation is provided instead).
** [Support] Framerate drops will no longer present an "Important Notification Occurred" status (it wasn't very useful).
** [Support] Added small delay in processing Console input if ~args.inputs.keyboard.key_down.enter~ is true.
   This will keep the console from being dismissed because of ~$gtk.reset~ being pre-populated when an exception occurs.
** [API] Pre-defined ~:pixel~ render target now available.
   Before ~(boot|tick)~ are invoked, a white solid with a size of 1280x1280
   is added as a render target. You can use this predefined render target to
   create solids and get ~args.outputs.sprites~ related capabilities.
   Example:
   This is an example showing how to render a red box using ~args.outputs.solids~:
   #+begin_src ruby
     def tick args
       args.outputs.solids << {
         x:  0, y:  0,
         w: 64, h: 64,
         r: 100, g: 0, b: 0
       }
     end
   #+end_src
   This will render the same red box, but leverages ~args.outputs.sprites~:
   #+begin_src ruby
     def tick args
       args.outputs.sprites << {
         x:  0, y:  0,
         w: 64, h: 64,
         r: 100, g: 0, b: 0
         path: :pixel,
         angle: 0
       }
     end
   #+end_src
** [API] Initial exploratory cut of a =Tweetcart= API has been created.
   The source code is available in the Contrib repo and also available locally under the =./docs/= directory.
   Example:
   The following code renders 10 ~Solids~ of various colors:
   #+begin_src ruby
     wht  = [255] * 3
     red  = [255, 0, 0]
     blu  = [0, 130, 255]
     purp = [150, 80, 255]

     TICK {
       bg! 0

       slds << [0, 0, 3, 3, 0, 255, 0, 255]

       sld!     10, 10
       sld!     20, 20, 3, 2
       sld!     30, 30, 2, 2, red
       sld!     35, 35, blu

       slds!    40, 40

       slds!   [50, 50],
               [60, 60, purp],
               [70, 70, 10, 10, wht],
               [80, 80, 4, 4, 255, 0, 255]
     }
   #+end_src
** [Samples] Added TeenyTiny MiniGameJam sample app: =/Users/amiralirajan/projects/dragonruby/samples/99_genre_teenytiny/=.
** [OSS] ~GTK::Recording~ and ~GTK::Replay~ have been open sourced.
** [OSS] OSS Contrib synced:
   #+begin_src sh
     commit aa8d3ac4bdccf522b8082a7fa7d595be2bd54b7d (origin/master, origin/HEAD)
     Author: Bartosz Podrygajlo <bartosz.podrygajlo@gmail.com>
     Date:   Wed Aug 4 11:19:06 2021 +0200

         Samples: Use to_radians for deg-to-rad conversion

         Replace the local implementation with the build-in Numeric.to_radians

     commit 26f20690be4da8f5091c720b1a25e32742c8c5fa
     Author: Pedro Brighenti <pedro.brighenti@gmail.com>
     Date:   Sun Aug 22 16:09:47 2021 +0100

         Fixed typo in 02_input_basics/02_mouse

     commit dae203d736b9d6db00c10a75208f44a3a937442f
     Author: leviongit <levi.duncan.self@gmail.com>
     Date:   Wed Aug 25 20:28:03 2021 +0200

         fix: console raising error at autocomplete request
   #+end_src
* 2.25
** [Support] [Pro] For Android releases, ~packageid~ can be specified in =./mygame/game_metadata.txt=.
   To verify the package name is correct for your Android build, you can use the following command:
   #+begin_src sh
     aapt dump badging PATH_TO_APK | grep package:\ name
   #+end_src
** [API] Added ~Outputs#clear_before_render~ which tells render targets to clear what's currently there.
** [Samples] Demonstration of ~clear_before_render~ is shown in =./samples/07_advanced_rendering/11_render_target_noclear/app/main.rb=
   Pressing the spacebar will clear the render target by setting ~clear_before_render~ equal to true.
** [Samples] Fixed tunneling issue in =./samples/04_physics_and_collisions/06_box_collision_3/app/main.rb=
   Thanks to @magiondiscord@discord for finding the edgecase (no pun intended).
** [C Extensions] [Pro] Binding generation now type checks and throws an exception in the event of a mismatch.
   An additional flag can be passed when generating bindings ~--no-typecheck~. For full documentation
   see: =./samples/12_c_extensions/README.md =
* 2.24
** [Bugfix] Labels within render targets scale correctly when windows are resized.
** [Bugfix] [Pro] Better error handling in the iOS wizard if app metadata fails to retrieve.
** [API] Added ~Numeric.mid? n1, n2~ which is similar to ~Numeric.between?~ except the numbers supplied to ~mid~ do not have to be in strictly increasing order.
** [OSS] Contributions from [[http://github.com/dragonruby/dragonruby-game-toolkit-contrib]] have been synchronized.
* 2.23
** [Bugfix] ~Hash#include?~ had invalid logic which has now been removed and should operate to core spec.
** [Bugfix] ~Hash#anchor_rect~ respects the anchor parameter passed to it as opposed to anchoring to 0.5, 0.5 only.
** [Bugfix] ~args.gtk.reset~ now clears ~args.audio~.
** [Bugfix] ~Numeric#(+|-|/|*) returns ~self~ instead of ~nil~ if arithmetic operation is performed against it.
** [Bugfix] ~Numeric#(+|-|/|*) can now be used with ~Array#inject~.
   NOTE: A special thank you to leviondiscord@discord for persistence in talking about this issue and
   taking the time to try to understand nil punning and the underlying reasoning for the original behavior (which proved
   to be a unnecessarily inconsistency in the case of arithmetic).
** [Bugfix] ~args.layout.debug_primitives~ are now cached. The grid overlay will render more quickly.
** [Bugfix] Inner exceptions from ~GTK::Geometry~ class methods are now retained and reported within the error message.
** [Bugfix] ~args.grid~ responds to ~x~, ~y~ which allows it to be used with geometric functions.
   You can use ~args.grid~ or continue to use ~args.grid.rect~.
** [Bugfix] Font glyph cache is invalided if the Window size changes.
** [API] ~args.audio~ now supports the ability to seek the audio to a specific location.
   Set ~args.audio[:some_audio][:playtime]~ to seconds (float) representing the point in time you
   want the audio to seek to.
   Take a look at the audio_mixer sample app for full api usage.
** [Samples] Audio Mixer sample app got a solid facelift. =./samples/07_advanced_audio/01_audio_mixer/app/main.rb=
** [Samples] Performance based sample apps are better labeled and contain documentation/fixes for new override methods.
** [Support] The sprites under ~mygame/sprites/(square|circle|isometric|hexagon)~ have been redone (a lot nicer looking).
** [Support] ~args.outputs.lines~ can now accept rectangular primitives ~(x|y|w|h)~.
   If the primitive does not respond to ~(x2|y2)~, then ~(w|h)~ will be used to derive ~(x2|y2)~. This
   change makes the definition of horizontal and vertical lines more intuitive.

   Instead of defining a horizontal line like this:
   #+begin_src ruby
     args.outputs.lines << { x:   0, y: 360, x2: 1280, y2: 360 }
     args.outputs.lines << { x: 640, y:   0, x2:  640, y2: 720 }
   #+end_src

   You can instead do this:
   #+begin_src ruby
     args.outputs.lines << { x:   0, y: 360, w: 1280 }
     args.outputs.lines << { x: 640, y:   0, h:  720 }
   #+end_src
** [Support] Console font decreased slightly to give more real estate.
** [Support] Console will apply color/formatting to comment blocks (making code blocks easier to read).
** [Support] Slight performance improvements to ~OpenEntity~.
** [Support] ~Hash#method_missing~ expanded to allow access to methods that collide with core apis.
   The ~Hash#method_missing~ capability allows you to access ~some_hash[:some_key]~, by using ~some_hash.some_key~ instead.
   For keys that conflict with core ~Hash~ api's, you can now suffix the method with an ~underscore~. Example: You
   can access ~some_hash[:length]~ using ~some_hash.length_~.

   Using the ~dot~ operator over ~Hash#[]~ isn't required, but it is encouraged (sample apps will opt to use the ~dot~
   operator for accessing keys in a ~Hash~, using the ~underscore~ suffix as needed).
** [Deprecation] [Soft] ~Hash#(solid|sprite|label|line|border)~ methods log a deprecation warning and suggest new methods usage.
*** New methods
   NOTE: Given how long these methods have been around, it's unlikely they will be removed for *very* long time.
   Here are the new method options:
   - ~Hash#(solid!|to_solid)~
   - ~Hash#(sprite!|to_sprite)~
   - ~Hash#(label!|to_label)~
   - ~Hash#(line!|to_line)~
   - ~Hash#(border!|to_border)~
*** Sample Usage
    These new methods accept a ~Hash~ as an additional parameter that will perform a ~Hash#merge!~
    with the object it's called on. They also better communicate that these primitive
    methods cause side effects. The existing methods did not communicate this which is why they are
    being deprecated.

    This is how ~Hash#border~ is currently being used:
    #+begin_src ruby
      def tick args
        color = { r: 255, g: 0, b: 0 }
        cell  = {
          x:   0,
          y:   0,
          w: 100,
          h: 100
        }
        args.outputs.primitives << cell.merge!(color).border
      end
    #+end_src

    You'll want to use ~Hash#border!~ instead:
    #+begin_src ruby
      def tick args
        color = { r: 255, g: 0, b: 0 }
        cell  = {
          x:   0,
          y:   0,
          w: 100,
          h: 100
        }
        args.outputs.primitives << cell.border!(color)
        # args.outputs.primitives << cell.merge(color).border! # this is also valid
      end
    #+end_src

    Use ~Hash#to_border~ if you *don't* want to mutate the original ~Hash~:
    #+begin_src ruby
      def tick args
        color = { r: 255, g: 0, b: 0 }
        cell  = {
          x:   0,
          y:   0,
          w: 100,
          h: 100
        }
        args.outputs.primitives << {
          x: 0,
          y: 0,
          w: 100,
          h: 100
        }.to_border(color)
      end
    #+end_src
* 2.22
** [Pro] [iOS] [Bugfix] Added missing icon files for ios and missing ios_metadata.txt template file.
** [API] ~GTK::Runtime#http_post_body url:string, body:string, headers:array[string]~
   ~args.gtk.http_post_body~ can be used to post raw data (with the responsibility of encoding left to the dev).
   Example:
   #+begin_src ruby
     def tick args
       if args.inputs.keyboard.key_down.enter
         json = "{ \"userId\": \"1000\", \"name\": \"Artorias of the Abyss\" }"
         args.gtk.http_post_body "http://tempuri.com/updated-profile",
                                 json,
                                 ["Content-Type: application/json"
                                  "Content-Length: #{json.length}"]
       end
     end
   #+end_src
** [Support] ~GTK::Runtime#notify_extended!~ now accepts ~overwrite~ as an option.
   Example:
   #+begin_src ruby
     def tick args
       if args.inputs.keyboard.key_down.enter
         args.gtk.notify_extended! message: "message to show", # message to show
                                   durations: 300,             # how many ticks to show the message
                                   env:       :prod,           # by default, notifications only happened in :dev
                                   overwrite: true             # if this value is true, the notification will
                                                               # shown even if another one is currently in progress
       end
     end
   #+end_src
** [Support] Better method missing exception formatting if the object's inspect is very long.

* 2.21
** [Samples] Added farming simulator starting point: =./samples/99_genre_crafting/farming_game_starting_point/=
** [Pro] [iOS] Updated iOS Wizard to consult metadata/ios_metadata.txt for iOS Specific configurations.
** [Support] Added a more streamlined means to get autocomplete suggestions: http://localhost:9001/dragon/autocomplete/
** [Support] DragonRuby Console prints backtrace for exceptions if helpful information is contained in it.

* 2.20
** [Bugfix] ~GTK::Runtime#benchmark~ reports completion time if only a single lambda is provided.
** [OSS] ~GTK::Runtime#benchmark~ has been open sourced.
** [API] Added ~args.layout.rect_group~ which allows you to layout a group of primitives
   Entries of the group can be offset by a delta row/col value. This is useful if you want to
   position primitives as if they were in a table. Here's an example of presenting a collection
   of labels each offset by a delta row ~drow~:
   #+begin_src ruby
     def tick args
       args.state.player.x ||= 640
       args.state.player.y ||= 360
       args.state.player.x  += 10
       args.state.player.y  -= 10

       debug_labels = args.layout
                          .rect_group row:  0,   # starting row
                                      drow: 0.5, # row amount to offset set each item by (delta row)
                                      col:  0,   # starting col
                                      group: [   # items representing the group
                                        { text: "player.x: #{args.state.player.x}" },
                                        { text: "player.y: #{args.state.player.y}" },
                                      ]
       args.outputs.labels << debug_labels
     end
   #+end_src
** [Samples] New sample app: =./samples/99_genre_fighting/01_special_move_inputs/app/main.rb=
   Sample app added that shows how to capture "special moves" like in a fighting game.
** [Bugfix] Ensure custom console buttons show up in both dev and production builds.

* 2.19
** [Bugfix] Exception no longer thrown when requiring a brand new file.
** [Support] [Important] Server Side Request Forgery vulnerability patch for DragonRuby Game Toolkit Web Console (http://localhost:9001)
   All http endpoints that submit data to DragonRuby now only accept ~application/json~ payloads (~x-www-form-urlencoded~ is no longer allowed).
   This change patches a SSRF vulnerability that would allow a malicious website to process request against
   ~http://localhost:9001/dragon/eval/~ and execute arbitrary code on your machine.

   Special thanks to @mooff@discord for bringing up this concern and @kfischer_okarin@discord for verifying it.

   The new api interaction is as follows:
*** From curl:
   #+begin_src sh
     curl -H "Content-Type: application/json" --data '{ "code": "$result = $args.state" }' -X POST http://localhost:9001/dragon/eval/
   #+end_src
*** From DragonRuby Game Toolkit
   #+begin_src ruby
     def tick args
       if args.inputs.keyboard.key_down.r
         json = <<-S
   {
     "code": "
   log 'received request from $gtk.http_post'
   $gtk.console.show
   $result = 1 + 2
   "
   }
   S
         args.state
             .http_eval_request = args.gtk
                                      .http_post "http://localhost:9001/dragon/eval/",
                                                 { "body" => json },
                                                 [ "Content-Type: application/json" ]
       end
       if (args.state.tick_count.zmod? 60) && args.state.http_eval_request && args.state.http_eval_request.complete
         puts args.state.http_eval_request.response_data
       end
     end
   #+end_src
* 2.18
** [API] Added ~args.inputs.controller_(one|two).(key_down|key_held|key_up).(back|select)~.
** [API] Added ~args.inputs.controller_(one|two).(key_down|key_held|key_up).(home|guide)~.
** [API] Primitives now support ~blendmode_enum~ which can be used to inform how transparency should be blended.
   You may have encountered render artifacts where opacity of a sprite would take on the background color of a render target,
   or text of a label had quality degradation when included in a render target.
   This can now be resolved by setting the ~blendmode_enum~ to ~0~. Example:
   #+begin_src ruby
     def tick args
       # render target has transparent background
       args.render_target(:camera).background_color = [0, 0, 0, 0]

       # set blendmode_enum to 0 for label to retain quality
       args.render_target(:camera).labels <<  { x: 700, y: 300, text: 'Hello World', blendmode_enum: 0 }

       # set blendmode_enum to 0 for sprite so that background_color isn't blended in
       args.render_target(:camera).sprites << { x: 700,
                                                y: 300,
                                                w: 300,
                                                h: 300,
                                                path: 'sprites/some-sprite-with-feathering.png',
                                                blendmode_enum: 0 }

       args.outputs.sprites << { x: 0, y: 0, w: 1280, h: 720, path: :camera }
     end
   #+end_src
   The following blend modes are supported: 0 (none), 1 (alpha), 2 (add), 3 (mod), 4 (multiply).
** [Samples] Sample app demonstrating ~blendmode_enum~ has been added: =./samples/07_advanced_rendering/10_blend_modes/=.
** [Bugfix] Emscripten/web builds will now allocate as much memory as needed to run the game.
   The compilation of wasm games now set ~ALLOW_MEMORY_GROWTH~. If you had issues with large sound files
   not loading within a web build, this change should resolve that issue.
** [Support] Added ~GTK::Runtime#benchmark~ which can be used to gauge performance.
   Example usage:
   #+begin_src ruby
     def tick args
       # press r to run benchmark
       if args.inputs.keyboard.key_down.r
         args.gtk.console.show
         args.gtk.benchmark iterations: 1000, # number of iterations
                            # label for experiment
                            using_numeric_map: -> () {
                              # experiment body
                              v = 100.map do |i|
                                i * 100
                              end
                            },
                            # label for experiment
                            using_numeric_times: -> () {
                              # experiment body
                              v = []
                              100.times do |i|
                                v << i * 100
                              end
                            }
       end
     end
#+end_src
** [Support] Better error message/exception for method missing on value types.
** [Support] ~args.layout.debug_primitives~ will draw the cells on the screen to help with placement.
   ~args.layout.rect(row:, col:, w:, h:)~ is a great way to layout controls. The ~debug_primitives~ function
   will render an overlay to help you with placement. Example:
   #+begin_src ruby
     def tick args
       args.outputs.debug << args.layout.debug_primitives
     end
   #+end_src
** [Bugfix] ~args.inputs.http_requests { |req| req.body }~ will now exclude the "Content-Disposition" envelope.
   Performing an ~args.gtk.http_post url, form_fields~ with populated form_fields creates a Content-Disposition envelope
   in the http request. The embedded web server's ~request.body~ now excludes that part of the payload to make parsing
   the body easier. ~request.raw_body~ has been added to show the unaltered http payload if you need it.
** [Support] [Experimental] ~http://localhost:9001/dragon/eval/~ supports requests from ~args.gtk.http_post~.
   Here is an example of how to request an eval of code over http via ~gtk.http_post~
   #+begin_src ruby
     def tick args
       if args.inputs.keyboard.key_down.r
         code_to_eval = <<-S
   log 'received request from $gtk.http_post'
   $gtk.console.show
   $result = 1 + 2
   S
         args.state
             .http_eval_request = args.gtk
                                      .http_post "http://localhost:9001/dragon/eval/",
                                                 { "body" => code_to_eval }
       end
       if (args.state.tick_count.zmod? 60) && args.state.http_eval_request && args.state.http_eval_request.complete
         puts args.state.http_eval_request.response_data
       end
     end
   #+end_src
** [Support] Rendering should be 10% to 15% faster.
   Enumeration of primitives uses a new module ~Object#fn#each_send~ which is faster than
   using a while loop. Here is an example of how to use ~fn.each_send~:
   #+begin_src ruby
     def process_item i

     end

     def process_very_large_array
       very_large_array = ...

       fn.each_send very_large_array, # array to process
                    self,             # object containing method to invoke
                    :process_item     # name of method to invoke for each item
     end
   #+end_src

* 2.17
** [Bugfix] Fixed another reload edgecase related to: Files loaded on startup will not be loaded again on frame 57 (hotloading is deferred until after the game has been fully initialized).

* 2.16
** [Bugfix] [Pro] Android 32-bit deployment should now work.
** [Support] [Pro] Android deployment are (for now) always production builds. Instructions for http server:
   If you want to have access to your app over http, you will need to put the following line in ~app/main.rb~
   before deploying:

   #+begin_src ruby
     def tick args
       args.gtk.start_server! port: 9001, enable_in_prod: true
       ....
     end
   #+end_src
** [API] ~Runtime#calcspritebox~ added.
   Calling ~args.gtk.calcspritebox PATH~ will return the ~w~ and ~h~ of the sprite as an array/tuple.
** [Support] Better error messages in the event of a ~uninitialized constant~ Exception when invoking ~require~.
** [Support] Better coloring of codeblocks begin/end within the Console.
** [Bugfix] Added additional Raspberry Pi configurations (arm32). DRGTK running on Raspberry Pi's should work now.
** [Bugfix] Files loaded on startup will not be loaded again on frame 57 (hotloading is deferred until after the game has been fully initialized).
** [Bugfix] Allow startup even if audio isn't available.
** [API] [Bugfix] ~Geometry::inside_rect?~ will return ~nil~ instead of throwing an exception if either argument passed into it are ~nil~.

* 2.15
** [Bugfix] [Pro] ~dragonruby-publish~ no longer fails with ~ios-device~ error.
** [API] ~Numeric#clamp~ now accepts a single parameter (representing ~min~ value).
** [Support] Better Console visuals/information in the event of a ~method_missing~ exception.
** [Support] Better formatting of "Did you mean?" in the event of a ~method_missing~ exception.
** [Support] Added help text in Console stating that ~ctrl+g~ can be used to clear the prompt.
** [Bugfix] Console automatically closes in the event of a syntax error being fixed.

* 2.14
** [Samples] Added sample app that shows how to create a very simple camera =./samples/07_advanced_rendering/07_simple_camera/=.
** [Pro] [Support] Compiler optimizations for iOS builds. Your iOS apps should be quite a bit faster now.
** [API] Better error handling missing methods on ~args.inputs.keyboard.KEYBOARD_KEY~.
** [API] Added ~args.gtk.version_pro?~ which will return ~true~ for the Pro version of DragonRuby Game Toolkit.

* 2.13
** [Samples] Added sample app that you can use as a starting point for Classic Jam: Guantlet Edition =./samples/99_genre_dungeon_crawl/classics_jam/=
** [API] ~Geometry~ apis no longer rely on ~left~, ~right~, ~top~, and ~bottom~ allowing you to use anything that ~respond_to~ ~x~, ~y~, ~w~, ~h~.
** [API] Added ~args.inputs.directional_angle~ which will return nil, 0, 45, 90 ... 360 depending on if ~up~, ~down~, ~left~, ~right~ are pressed.
** [API] ~OpenEntity~ and ~StrictEntity~ include the ~Geometry~ module.
** [API] Added ~OpenEntity#merge~ which invokes ~(OpenEntity#as_hash).merge~.

* 2.12
** [Support] Better call stack for exceptions.
** [Support] Added ~args.fn.pretty_print OBJECT~ and ~args.fn.pretty_print_verbose OBJECT~.
   These printing apis are still a work in progress/might not be perfect.
** [Bugfix] Fixed Raspberry Pi executable segfaulting (it was totally @icculus's fault).
** [Bugfix] Fixed ~GTK#http_(get|post) for Mojave, while at the same time not breaking Catalina/Big Sur (it was totally Apple's fault).
** [Bugfix] [Pro] Fixed unhandled exception caused by missing headers when responding to http requests.
** [API] Added ~Geometry#rotate_point(target_point, degrees_to_rotate, pivot_point = [0, 0])~.
** [API] Added ~FFI::Draw#draw_label_2~ which accepts ~vertical_alignment_enum~ as a new parameter.
   ~FFI::Draw#draw_label~ defaults ~vertical_alignment_enum~ to ~2~ for backwards compatibility.
   ** [API] ~Label~ primitive now supports ~vertical_alignment_enum~.
   Example:

   #+begin_src ruby
     def tick args
       args.outputs.labels << {
         # x position of the label's origin
         x: 640,

         # y position of the label's origin
         y: 360,

         # text of the label
         text: "Sample Label",

         # red color of the label
         r: 0,

         # green color of the label
         g: 0,

         # blue color of the label
         b: 0,

         # alpha of the label
         a: 255,

         # default value of size_enum is 0 this virutal value of zero represents
         # the recommended font size that would be legible on devices large and small
         # this value can be negative to go smaller (but with the risk of being hard to read
         # on mobile or handheld screens)
         size_enum: 0

         # this represents the horizontal alignment of the label, which is calculated using
         # the far left value of the string (~x~) and its render width.
         # 0 (default value) means ~left~ aligned, 1 means ~center~ aligned, 2 means ~right~ aligned
         alignment_enum: 0,

         # this represents the vertical alignment of the label, which is calculated using
         # the asension value of the string (~h~) and the bottom location of the string (~y~).
         # 0 means ~bottom~ aligned, 1 means ~center~ aligned, 2 (default value) means ~top~ aligned
         # IMPORTANT: To reiterate, the default value of this enum is 2 for backwards compatibility.
         vertical_alignment_enum: 0,

         # the font for the label
         font: "font.ttf"
       }
     end
   #+end_src

* 2.11
** [Sample] Added a very simple sample app that shows how to move a sprite using the keyboard =samples/02_input_basics/01_moving_a_sprite=.
** [API] ~attr_gtk~ adds ~new_entity~ to the class that invokes this class macro.
** [API] Added ~args.temp_state~. All values are set to ~nil~ on this object after ~tick~ is processed.
** [API] ~Hash#merge(!)~ accepts both ~Entities~ and ~Hashes~.
** [API] ~Hash~ responds to method missing and will forward to ~[key](=)~.
** [API] ~Layout#rect~ accepts ~d(x|y)_ratio~ which alters the final rectangle by the ratio specified.
** [API] ~Layout#rect~ accepts ~merge~ which will add the hash specified into the resulting rectangle.
** [API] Added ~Runtime#platform?(symbol)~ which consults ~Runtime#platform_mappings~ to make it easier to determine the platform your game is running on.
** [Support] ~$wizards.itch.start~ performs a the publishing process for you, but no longer attempts to deploy to Itch.io using Butler (Butler is too unstable).
** [Support] [Pro] ~$wizards.ios.start~ now asks for App's version number.
** [Support] Performance improvements to ~Numeric#==~.

* 2.10
** [Sample] [Bugfix] Fixed naming of roguelike sample apps (they were wrong).
** [Pro] Ahead of time/bytecode compilation added.
   In the manifest file, add ~compile_ruby=true~. ~./dragonruby-publish~ will do the work.
** [Pro] [Bugfix] Fixed issue where game would not boot if main.rb was compiled (AOT will totally work this time).
** [Pro] [Bugfix] ~dragonruby-publish~ will compile ruby files outside of =mygame/app= (such as mygame/lib).

* 2.9
** [Sample] [Bugfix] Fixed exception in breadth first search sample app =samples/13_path_finding_algorithms/01_breadth_first_search=.
** [Pro] [Bugfix] Fixed premature ~free~ in AOT which caused it to fail loading.

* 2.8
** [Pro] [Support] ~args.inputs.http_requests~ has been added so that you can prototype multiplayer games over http.
   Here is an example usage:
   #+begin_src ruby
   def tick args
     args.gtk.start_server! port: 9001,  enabled_in_prod: true
     args.inputs.http_request.each do |req|
       puts req
       req.respond 200, "hello from DragonRuby", { 'Content-Type' => 'text/plain }
     end
   end
   #+end_src
** [Pro] [Sample] Added sample app that shows how to process http request =./samples/11_http/02_web_server=.
** [Pro] [iOS] Added the ability to create a distribution build of an iOS app.
   To deploy to your device as a dev build, open up the Console and type ~$wizards.ios.start env: :dev~.
   To create a package that can be uploaded to Apple, open up the Console and type ~$wizards.ios.start env: :prod~.
** [Pro] [Bugfix] [iOS] Remote hot loading of a game deployed to your iOS device is stable and will not perform unnecessary reloads.
** [Pro] Ahead of time/bytecode compilation added.
   In the manifest file, add ~compile_ruby=true~. ~./dragonruby-publish~ will do the work.
** [Perf] Minor improvements made to arithmetic operations.
** [Samples] Created a much simpler sample app that shows how to play sounds.
** [OSS] Hot loading machinery has been open sourced.
** [Sample] Added sample app that shows a z-targeting game mechanic =./samples/07_advanced_rendering/08_z_targeting_camera=.
** [Support] DragonRuby GTK when in development mode spins up an http endpoint that exposes capabilities of the Console as a webpage.
   The default port for the http endpoint is a port number 9001 (it's a port number over 9000). After
   starting up DragonRuby, go to http://localhost:9001 to see the what options you have available (these options will expand over time).
** [Sample] Added a Tower Defense sample app =samples/13_path_finding_algorithms/09_tower_defense=.

* 2.7
** [Bugfix] Html5 exception when trying to find a missing metadata file no longer occurs.
** [API] ~attr_rect~, ~attr_sprite~ class macros updated so that they can be mixed into ~Entities~.
   #+begin_src
     def tick args
       args.state.player ||= args.state.new_entity :player, x: 0, y: 0, w: 100, h: 100 do |e|
         e.attr_rect
       end

       puts60 (args.state.player.intersect_rect? [10, 10, 10, 10])
     end
   #+end_src
** [Docs] Better themeing of table of contents.
** [Docs] Added docs for easing functions and string functions. Added ~args.easing~ and ~args.string~ so you have access to class functions like ~args.geometry~.
** [Bugfix] ~args.inputs.directional_vector~ now returns the correct normalized values for diagonals.
** [Bugfix] ~args.layout.rect~ now respects ~args.grid.origin_center!~.
** [API] Hash responds to ~pos~ and ~z~ so you can access those properties via the dot operator instead of using indexed symbols.
** [Samples] Misnamed sample app has been renamed to =bullet_hell= to reflect what the sample shows.

* 2.6
** [Samples] Fixed \r\n syntax error in animation creator sample app that only affected Window (grr).

* 2.5
** [Samples] [Pro] Fixed exception in synth sample app (no really this time).

* 2.4
** [OSS] Contributions from [[http://github.com/dragonruby/dragonruby-game-toolkit-contrib]] have been synchronized.
** [OSS] Remote hot load client has been open sourced.
** [Samples] Added starter template from Nokia Jam 3 under =./samples/99_lowrez=.
** [Samples] [Pro] Fixed exception in synth sample app.
** [Support] Initial work to include line number and file in the event on an exception.

* 2.3
** [Bugfix]  Ensure that all requires are processed before running unit tests.
** [Samples] =./samples/99_genre_3d/02_wireframe=: Sample app added to show how to create a wireframe using ~.off~ (Object File Format) geometry files.
** [Samples] =./samples/13_path_finding_algorithms= Sample apps added that show various types of pathfinding.
** [Samples] =./samples/(08_bouncing_on_collision|09_arbitrary_collision|10_collision_with_object_removal) Sample apps added that show collision of arbitrary polygons.
** [Samples] =./samples/99_genre_rpg_tactical= Sample app added that show how to do player/enemy turns in a tactical RPG.
** [API] Added a means to get autocompletion suggestions from the Runtime via ~GTK::Runtime::suggest_autocomplete~. You can use this to create fancy autocompletion plugins for your preferred editor.
   Example usage:
   #+begin_src ruby
     # API: $gtk.suggest_autocompletion index: STRING_INDEX_REPRESENTING_CURSOR_LOCATION, text: SOURCE_CODE

     # Write something like the following to app/mailbox.rb
     # get the autocomplete suggestions for the source code with the cursor at index 21
     suggestions = $gtk.suggest_autocompletion index: 21, text: <<-SOURCE_CODE
       def tick args
         args.
       end
     SOURCE_CODE

     # write autocomplete suggestions to a file for reading later
     $gtk.write_file 'autocomplete.txt', (suggestions.join "\n")
   #+end_src
** [API] The ~attr_gtk~ class macro now adds ~layout~ as a member variable.
** [API] Added ~Kernel#puts(6|60|600). Using ~puts6~ will print to the console ever 6 ticks, ~puts60~ will print every second, ~puts600~ will print to the console every 10 seconds.
** [API] Added ~Mouse#inside_rect?~.
** [API] Added ~Geometry#center_inside_rect_(x|y)~ which only centers rects horizonally (x) or vertically (y).
** [API] ~GTK::Layout#rect~ now accepts ~d(x|y|w|h)~ parameters.
   Example usage:
   #+begin_src ruby
     # note: the layout is composed of 12 rows and 24 columns, rows go from top to bottom and columns go from left to right.
     #       ~args.layout.rect~ returns a rectangle represented as a ~Hash~ with ~:x~, ~:y~, ~:w~, and ~:h~.
     # render a border at row 0, column 0, with a width 1 and height of 1
     def tick args
       args.outputs.borders << (args.layout.rect row: 0, # you have access to 12 rows (float values are allowed)
                                                 col: 0, # you have access to 24 columns (float values are allowed)
                                                 w:   1, # w and h are represented in cell units (not pixels)
                                                 h:   1)
     end
   #+end_src

   Example usage with added parameters
   #+begin_src ruby
     # render a border at row 0, column 0, with a width 1 and height of 1, but shift the rectangle by dx, dy (represented in pixels),
     # and increase/decrease by dw, and dh (reprsented in pixels)
     def tick args
     def tick args
       args.outputs.borders << (args.layout.rect row:   0, # you have access to 12 rows (float values are allowed)
                                                 col:   0, # you have access to 24 columns (float values are allowed)
                                                 w:     1, # w and h are represented in cell units (not pixels)
                                                 h:     1,
                                                 dx:  -10, # after calculating, shift x by -10 pixels (left)
                                                 dy:   10, # after calculating, shift y by 10 pixels (up)
                                                 dw:  100, # after calculating, increase the w by 100 pixels
                                                 dh:  200) # after calculating, increase height by 200 pixels
     end
   #+end_src
** [OSS] ~GTK::Runtime::Autocomplete~ (the logic for suggesting autocompletions) has been open sourced.
** [OSS] ~GTK::Runtime::Framerate~ (the logic for calculating framerate) has been open sourced.
** [OSS] ~GTK::Layout~ (the logic to calculate aspect-ratio-aware rectangles within a 12x24 grid) has been open sourced.

* 2.2
** [Bugfix] Better support for requires for paths in nested directories.
** [Bugfix] Better support for requires for paths outside off the app directory.
** [Support] Added ~--test~ command line argument that will automatically start tests withouth explicitly having to call ~$tests.start~.
   Take a look at ~samples/10_advanced_debugging/03_unit_tests~ for samples.

* 2.1
** [Bugfix] Better support for nested require statements ~require~ and top level ~require~ statements that depend on ~tick_count == 0~.
** [Bugfix] Ensure that screen remains black while nested and top level requires are being processed.

* 2.0
** [IMPORTANT] This version does NOT have any breaking changes.
** [Pro] [API] [Audio] Sound synthesis sample app now includes square, triangle, and sawtooth wave generation.
** [Pro] [Bugfix] [Android] Android deployment issues related to the latest SDKs have been fixed.
** [Support] Apple Silicon publishing added.
** [API] ~$gtk.version~ has been added and will return a ~String~ (in this case "2.0"). Assume the version is "1.0" if ~$gtk.respond_to? :version~ returns ~false~.
** [Bugfix] ~require~ parsing improved and facilities put in place to ensure all files are required before ~tick~ is invoked.
** [Bugfix] Flashing of background color when your game starts has been fixed. The default starting color is black.
** [Bugfix] [Http] $gtk.http_post now works correctly with form collections.
** [Samples] New sample app ~samples/04_physics_and_collisions/06_box_collision_3~ added that shows auto-tiling concepts with dynamically changing collisions.

* 1.27
** [Pro] [API] [Audio] Sound synthesis capabilities added.
** [Pro] [Samples] [Audio] Added a new sample app samples/01_rendering_basics/07_sound_synthesis/ that shows how to create sine waves.
** [Pro] [OSS] [iOS] iOS Wizard open sourced.
** [Bugfix] Scaling issues fixed with HTML5 games.
** [API] Added ~GTK::Runtime#openurl~ ~args.gtk.openurl(some_url)~.
** [API] Added ~GTK::Runtime#set_window_fullscreen~ ~args.gtk.set_window_fullscreen(true|false)~.
** [Bugfix] Sprite angles now accept float values instead of just ints.
** [Bugfix] More accurate results for ~args.gtk.calcstringbox~.
** [Support] Better cursor rendering in the Console.
** [Experimental] Added component layout api (open sourced), take a look at samples/01_rendering_basics/07_sound_synthesis/ to see how it's used to layout buttons.
** [Support] Emscripten dependencies updated (hopefully yielding better HTML5 games).
** [OSS] [iOS] Itch Wizard open sourced.

* 1.26
** [Pro] [Samples] [C Extensions] New sample app added showing how to incorporate your own regex library: 12_c_extensions/02_intermediate
** [Pro] [Samples] [C Extensions] New sample app added showing how to manipulate single pixels: 12_c_extensions/03_native_pixel_arrays
** [Samples] [API] [Experimental] Added a new sample app 01_rendering/06_audio_mixer that gives you more control over sounds.
   Check out the YouTube video at [[https://www.youtube.com/watch?v=b1pL4pEWymI&ab_channel=AmirRajan]]
** [Docs] Docs added for ~outputs.screenshots~ (thank you kfischer_okarin@discord).
** [Support] ~trace!~ now provides timing information (thank you danhealy@discord).
** [Support] Console now supports left and right movement of the cursor (thank you kfischer_okarin@discord).
** [Bugfix] ~args.state~ serialization and deserialization now takes into consideration hashes that were stored by reference.
** [API] Added ~attr~ class method that is an alias for ~attr_accessor~.
** [API] Re-added ~args.gtk.save_state~ and ~args.gtk.load_state~ as convenience methods.
   This is what the convenience methods do:
   #+begin_src ruby
     def save_state
       serialize_state "game_state_#{Time.now.to_i}.txt", @args.state
       serialize_state "game_state.txt", @args.state
     end

     def load_state
       @args.state = deserialize_state 'game_state.txt'
     end
   #+end_src
** [OSS] Implementation of draw order and the underlying FFI methods have been open sourced.
** [API] ~GTK::Runtime#console_button_primitive~
   The ~args.gtk.console_button_primitive~ is a function that returns and handles the click of a button that will render in the top right
   corner of the screen. If this button is clicked, then the console will be shown. This is useful for when you want have the console
   readily available on Desktop or if you need to bring up the console on mobile devices (mobile is available in DragonRuby Game
   Toolkit Pro only). To use this, add the following to your ~tick~ method:
   #+begin_src ruby
     def tick args
       args.outputs.reserved << args.gtk.console_button_primitive
     end
   #+end_src
   The source code for this function is:
   #+begin_src ruby
   module GTK
     class Runtime
       def console_button_primitive
         return nil if $gtk.production
         return nil if @console.visible?

         @console_button ||= { x: 55.from_right, y: 50.from_top, w: 50, h: 50, path: 'console-logo.png', a: 80 }.sprite
         if @args.inputs.mouse.click && (@args.inputs.mouse.inside_rect? @console_button)
           @args.inputs.mouse.click = nil
           @console.show
         end
         @console_button
       end
     end
   end
   #+end_src
** [Bugfix] HTML game will now be uploaded to Itch.io along with Mac, Linux, PC, and Raspberry Pi binaries.
** [Support] Emscripten compiler has been updated.
* 1.25
** [Bugfix] Hash#anchor_rect wasn't working like Array#anchor_rect (now it is).
** [API] Added Mouse#inside_circle? so you don't have to do ~args.inputs.mouse.point.inside_circle?~.
** [Bugfix] Mac app will no longer ask to monitor keyboard input when starting.
* 1.24
** [Bugfix] ~GTK::Runtime#(write|append)_file~
   ~$gtk.(write|append)_file in production mode will no long write to the
   app directory. You can get the write location of the file using
   ~gtk.get_game_dir~.
** [Wizard] [Experimental] Itch.io Wizard
   An Itch.io Wizard has been added to the Console as a menu button. you
   can also invoke the wizard via ~$wizards.itch.start~.
* 1.23
** [API] ~Numeric#randomize~
   ~Numeric#randomize~ can now accept the symbol ~:int~.
   ~(100.randomize :int)~ will return a random whole number between ~0~
   and ~100~ inclusive. Here are some other uses of ~Numeric#randomize~:
   #+begin_src ruby
     100.randomize :ratio        # returns a float between 0 and 100
     100.randomize :ratio, :sign # returns a float between 0 and 100, but negative or positive
   #+end_src
** [Bugfix] ~Label#size_enum~
   Fixed bug where a label's size_enum is larger than the maximum font
   size of the OS.
** [API] ~GTK::Runtime#(write|append)_file~ ~GTK::Runtime#(write|append)_file_root~
   This is kind of a breaking change, but should actually yield a nice
   development experience. ~$gtk.(write|append)_file~ will now write to
   your game directory as opposed to writing to the process execution
   directory. To write to the process execution directory, use
   ~gtk.(write|append)_file_root~.
** [Bugfix] ~def tick args~
   The simulation will run more consistently in the event a slow ~tick~
   occurs and won't try to "catchup" (which causes the game to run very
   fast for a few ticks).
* 1.22
** [Samples] Console Customization
   Sample app added that shows how to add custom buttons to the
   Console. The new sample app is located at ~./samples/99_genre_dev_tools/add_buttons_to_console~
* 1.21
** [Bugfix] Sprite Color Saturation
   There was a bug with rgb saturations on sprites. This bug was
   terminated with extreme prejudice.
* 1.20
** [Bugfix] Line Colors
   The green and blue values for lines and screenshots was flipped. This
   bug was terminated with extreme prejudice.
* 1.19
** [Samples] Sprite Rendering Performance
   Better sample apps showing a spectrum of ways to render a lot of
   sprites. All sprite_limits samples apps were reworked.
** [Support] Override Draw Call For Sprite
   Performance enhancements to draw calls and a means to override them
   completely if you really need to (take a look at the sprite limit
   sample apps).
** [Support] Troubleshooting Framerate
   Added better diagnostics for performance issues. Try
   ~$gtk.framerate_diagnostics~ from the console. This diagnostics
   information has been open sourced.
** [Samples] Sample Apps Reorganized
** [Bugfix] ~Outputs#background_color~
   Setting ~Output#background_color~ to an invalid value no longer segfaults.
** [Docs] Searching Sample Code
   The file docs/docs.html now contains all code from the sample apps so you only have to search in one place.
** [Samples] There are over 12,000 lines of sample code now :-)
* 1.18
** [Docs] Added the "Continuity of Design" to the "DragonRuby's Philosophy" section.
** [Docs] Added all source code that has been open sourced to the docs.html.
** [Support] ~$gtk.reset~ Enhancements
   ~$gtk.reset~ now resets the grids origin back to bottom left by calling the ~args.grid.origin_bottom_left!~ method.
** [API] ~Numeric#from_top~
   Added ~Numeric#from_top~ so that it's easier to position primitives:
   #+begin_src ruby
     args.outputs.labels << [10, 10.from_top, "hello world"]
   #+end_src
** [API] ~Object::attr_gtk~, ~Object::attr_sprite~, ~Object::attr_rect~ as instance methods.
** [API] ~Mouse#inside_rect?~
   Added ~Mouse#inside_rect?~ (~args.inputs.mouse.inside_rect?~) which
   delegates to ~args.inputs.mouse.point.inside_rect?~.
** [Support] Added a collection of menu buttons for common tasks to DragonRuby Console.
* 1.17
** [MacOS] Updated minimum OS support to include MacOS 10.9+ (really I swear this time it's fixed definitely, maybe).
* 1.16
** [Bugfix] Fixed bug in HTML5 template that would cause an exception when releasing to Itch.
* 1.15
** [Support] Rendering Enhancements
   Rendering and simulation have been decoupled which will allow fps to
   be unbounded. ~tick~ will still run at 60 hz (we just render as fast
   as the platform allows).
* 1.14
** [Support] HTML5 Template Updated
   Better HTML5 template. Additional JS events added to handle loss of
   keyboard input within an iframe.
** [Bugfix] ~args.outputs.screenshots~ regression fixed.
** [Docs] Added documentation for a few more ~Numeric~ methods.
** [Samples] Animation Creator
   Brand new advanced sample app: 99_sample_sprite_animation_creator. The
   sample app uses ~args.outputs.screenshots~ and ~render_targets~
   heavily along with in memory queues as a means to consolidate events
   coming from different parts of the app.
* 1.13
** [API] Sprite angle now accepts fractional degrees.
** [Samples] Better font added to LOWREZJAM 2020 template.
** [API] ~args.outputs[RENDER_TARGET_NAME]~
   Added ~args.outputs[RENDER_TARGET_NAME]~ as an alias to
   ~args.render_target(RENDER_TARGET_NAME)~. Either of the following will
   work:
   #+begin_src ruby
     def tick args
       if args.state.tick_count == 1
          args.render_target(:camera).width  = 100
          args.render_target(:camera).height = 100
          args.render_target(:camera).solids << [0, 0, 50, 50, 255, 0, 0]
       end

       if args.state.tick_count > 0
         args.outputs.sprites << { x: 0,
                                   y: 0,
                                   w: 500,
                                   h: 500,
                                   source_x: 0,
                                   source_y: 0,
                                   source_w: 50,
                                   source_h: 50,
                                   path: :camera }
       end
     end

     $gtk.reset
   #+end_src

   Is the same as:

   #+begin_src ruby
     def tick args
       if args.state.tick_count == 1
          args.outputs[:camera].width  = 100
          args.outputs[:camera].height = 100
          args.outputs[:camera].solids << [0, 0, 50, 50, 255, 0, 0]
       end

       if args.state.tick_count > 0
         args.outputs.sprites << { x: 0,
                                   y: 0,
                                   w: 500,
                                   h: 500,
                                   source_x: 0,
                                   source_y: 0,
                                   source_w: 50,
                                   source_h: 50,
                                   path: :camera }
       end
     end

     $gtk.reset
   #+end_src
* 1.12
** [Samples] New LOWREZ Sample
   LOWREZ Jam sample app reworked in preparation for LOWREZ Jam 2020
   (starts on August 1st so hurry and join).
** [Docs] ~GTK::Mouse.docs~
   Docs added for GTK::Mouse, you can access them via the Console by typing ~GTK::Mouse.docs~ or ~$gtk.args.inputs.mouse.docs~.
** [MacOS] Updated minimum OS support to include MacOS 10.9+.
* 1.11
** [Bugfix] Fixed error in ~docs_search "TERM"~.
* 1.10
** [Support] Documentation infrastructure added (take a look at docs/docs.html).
   Bring up the DragonRuby Console.
   To search docs you can type ~docs_search "SEARCH TERM"~
   If you want to get fancy you can provide a ~lambda~ to filter documentation:
   #+begin_src ruby
      docs_search { |entry| (entry.include? "Array") && (!entry.include? "Enumerable") }
   #+end_src
** [Bugfix] ~Sprite#source_(x|y|w|h)
   Fixed sprite rendering issues with source_(x|y|w|h) properties on
   sprites.
** [Support] Removed Double Buffering
   Removed double buffering of game if framerate drops below 60
   fps. There have been quite a few performance enhancements that make
   this method unneeded (plus there will be future enhancments to
   rendering).
** [Support] Console Scroll Wheel Support
   Console now supports mouse wheel scrolling.
** [Support] One Time Notification Clean Up
   One time notifications have less noise/easier to read.
** [Bugfix] Orphaned ~app~ Directory
   Rogue ~app/main.rb~ directory will no longer be created if you run a sample app.
* 1.9
** [Bugfix] HTTP on windows should now work, for real this time.
** [Bugfix] Non-720p render targets now use correct coordinate system.
* 1.8
** [Bugfix] HTTP on windows should now work.
** [Bugfix] ~even?~ and ~odd?~ return the correct result for Fixnum.
** [Bugfix] ~args.intputs.mouse_wheel~ now reports the delta change in x and y correctly.
** [Bugfix] Improved analog joystick accuracy when converting to percentages.
** [Support] Console Tab Completion
   Incorporated pull request from https://github.com/kfischer-okarin that adds autocompletion to the Console.
   This is the PR:
     - https://github.com/DragonRuby/dragonruby-game-toolkit-contrib/commit/da0fdcfbd2bd9739fe056eb646920df79a32954c
     - https://github.com/DragonRuby/dragonruby-game-toolkit-contrib/commit/99305ca79118fa0704c8681f4019738b8c7a500d
* 1.7
** [BREAKING] ~args.inputs.mouse.wheel.point~
   ~args.inputs.mouse.wheel.point~ is gone. Use args.inputs.mouse.x and
   .y if you need cursor position.
** [BREAKING] ~args.inputs.mouse.wheel.(x|y)~
   ~args.inputs.mouse.wheel.(x|y)~ now represent the amount the
   mousewheel/trackpad has moved since the last tick and not the mouse
   cursor position. Use args.inputs.mouse.x and .y if you need cursor
   position.
* 1.6
** [API] ~Sprite#source_(x|y|w|h)~
   ~Sprite~ now supports source_(x|y|w|h). These properties are
   consistent with the origin being in the bottom left. The existing
   properties tile_(x|y|w|h) assumes that origin 0, 0 is in the top
   left. The code below will render the same sprite (in their respective
   coordinate systems):
   #+begin_src ruby
     # using tile_(x|y|w|h) properties
     args.outputs.sprites << { x: 0,
                               y: 0,
                               w: 1280,
                               h: 100,
                               path: :block,
                               tile_x: 0,
                               tile_y: 720 - 100,
                               tile_w: 1280,
                               tile_h: 100 }
   #+end_src

   is equivalent to:

   #+begin_src ruby
     # using source_(x|y|w|h) properties
     args.outputs.sprites << { x: 0,
                               y: 0,
                               w: 1280,
                               h: 100,
                               path: :block,
                               source_x: 0,
                               source_y: 0,
                               source_w: 1280,
                               source_h: 100 }
   #+end_src
   Note: if you provide both tile_(x|y|w|h) and source_(x|y|w|h). The
   values of tile_ will "win" so as not to break existing code out
   there.
** [Bugfix] Duplicate Requires
   Updated require to remove duplicate requires of the same file (or
   files that have recently been required).
** [Bugfix] Strict Entities Serialization
   Strict entities of different types/names serialize and deserialize
   correctly.
** [Samples] Render Targets with Alphas
   Updated render targets sample app to show two render targets with
   transparencies. No really, render targets now have a transparent
   background and respect opacity.
* 1.5
** [API] ~$gtk.(show|hide)_cursor~
   Added ~$gtk.show_cursor~ and ~$gtk.hide_cursor~ to show and hide the mouse
   cursor. The function only needs to be called once. EG:
   #+begin_src ruby
     def tick args
       args.gtk.hide_cursor if args.state.tick_count == 0
     end
   #+end_src
   The Jam Craft 2020 sample app updated to have more comments and demonstrate a custom mouse cursor.
* 1.4
** [Bugfix] ~$gtk.reset~
   Adding $gtk.reset at the bottom of main.rb will no longer cause an infinite loop.
** [Samples] Jam Craft 2020.
* 1.3
** [Samples] Added Better Help Text/Explanations
* 1.2
** [Bugfix] Top-level require statements within main.rb will load before invoking the rest of the code in main.rb.
** [Samples] Better keyboard input sample app.
** [Samples] New sample app that shows how to use Numeric#ease_spline.
** [Bugfix] Fixed "FFI::Draw cannot be serialized" error message.
* 1.1
** [Bugfix] Fixed exception associated with providing serialization related help.
** [Bugfix] Fixed comments on how to run tests from CLI.
** [Support] More helpful global variables added. Here's a list:
     - $gtk
     - $console
     - $args
     - $state
     - $tests
     - $record
     - $replay
** [API] inputs.keyboard.key_(down|held|up).any? and inputs.keyboard.key_(down|held|up).all? added.
** [Support] Recording gameplay and replaying streamlined a bit more. GIVE THE REPLAY FEATURE A SHOT! IT'S AWESOME!! Bring up the console and run: $record.start SEED_NUMBER.
** [Support] Bringing up the console will stop a replay if one is running.
* 1.0
** [News] DragonRuby Game Toolkit turns 1.0. Happy birthday!
** [Bugfix] args.state.new_entity_strict serializes and deserializes correctly now.
** [BREAKING] Entity#hash has been renamed to Entity#as_hash so as not to redefine Object#hash. This is a "private" method so you probably don't have to worry about anything breaking on your end.
** [BREAKING] gtk.save_state and gtk.load_state have been replaced with gtk.serialize_state and gtk.deserialize_state (helpful error messages have been added).
** [Support] Console can now render sprites (this is still in its early stages). Try $gtk.console.addsprite(w: 50, h: 50, path: "some_path.png").
** [API] Render targets now have a transparent background and respect opacity.
** [API] Render targets can be cached/programatically created once and reused.
** [Samples] A new render target sample app has been created to show how to cache them.
** [Samples] Easing sample app reworked/simplified.
** [Support] GTK will keep a backup of your source file changes under the tmp directory. One day this feature will save your ass.
