orange_zest 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 86f58491ecd24a1b7bc7f00fdf6ef8ededee32319660e83b4c97816a5a2d6263
+  data.tar.gz: fd151abcfe7ecbeac7fe08459d5bb12eda93d1f05f5044c50ee354212e8a1bf8
+SHA512:
+  metadata.gz: 733200a7e3ffd918dd961e90dc6a6185a5be1aa2fcb45a8a1c608c146955d8fd315411a3550edafe38a41954961733b5570653bc7f1cfabc12da9971eb201b44
+  data.tar.gz: 7110079d1c76dfc8de9a05b5c50d02c8d85798d3ab0652191ad8aabf549fa60b8f84de526360ead66a6163f489ff6005c679ee0d16ea91980d6afeeda73a91bb

data/.editorconfig

@@ -0,0 +1,2 @@
+[*.rb]
+indent_size = 2

data/.github/workflows/main.yml

@@ -0,0 +1,16 @@
+name: Ruby
+
+on: [push,pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.0.2
+        bundler-cache: true
+    - name: Run the default task
+      run: bundle exec rake

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2022-08-27
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,84 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at aaronc20000@gmail.com. All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior,  harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
+available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in orange_zest.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"

data/Gemfile.lock

@@ -0,0 +1,36 @@
+PATH
+  remote: .
+  specs:
+    orange_zest (0.1.0)
+      gosu
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.5.0)
+    gosu (9.9.9)
+    rake (13.0.6)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.0)
+
+PLATFORMS
+  arm64-darwin-21
+
+DEPENDENCIES
+  orange_zest!
+  rake (~> 13.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.2.22

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Aaron Christiansen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,45 @@
+# OrangeZest
+
+OrangeZest is a **lightweight layer on top of the excellent
+[Gosu game library](https://www.libgosu.org/)**.
+
+I absolutely love Gosu because it provides the perfect level of abstraction for you to approach a
+game's architecture however you like. _This_ is the architecture that I've enjoyed using for the
+[last](https://github.com/AaronC81/pet-peeve)
+[three](https://github.com/AaronC81/the-arcane-king)
+[games](https://github.com/AaronC81/mini-mall-maker)
+I've created for the Gosu Game Jam, and I've finally decided to break it out into a separate gem to
+make it more reusable.
+
+OrangeZest encourages using OOP rather than ECS, although it's lightweight and unopinionated enough
+that you might be able to implement ECS on top of it. (The words "component" and "entity" in
+OrangeZest _do not_ refer to the ECS concepts - they just happen to fit OrangeZest's concepts too!)
+
+OrangeZest provides:
+
+- _Components_, objects which can be instantiated into the game world to provide behaviour
+- _Entities_, a subclass of components which has a position and animation
+- _Groups_, to bundle together related components into one
+- A very simple animation system
+- Simple mathematical primitives (points and boxes)
+
+## Installation
+
+This gem is available on RubyGems as `orange_zest`. Add it to your Gemfile as `gem 'orange_zest'`,
+or install it globally with `gem install orange_zest`.
+
+## Getting Started
+
+See the `examples` directory for some sample scripts which use OrangeZest. 
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/AaronC81/orange_zest. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/AaronC81/orange_zest/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the OrangeZest project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/AaronC81/orange_zest/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/examples/basic.rb

@@ -0,0 +1,86 @@
+require 'gosu'
+require 'orange_zest'
+
+include OrangeZest
+
+WIDTH = 640
+HEIGHT = 480
+
+# First, we'll define a component responsible for clearing the screen. Components can define 
+# `#update` and `#draw` to perform actions during Gosu's update and draw steps.
+class ClearScreen < Component
+  def draw
+    Gosu.draw_rect(0, 0, WIDTH, HEIGHT, Gosu::Color::WHITE)
+  end
+end
+
+# Now we'll define an entity, a special kind of component with a position and animation system.
+class BouncingBall < Entity
+  IMAGE = Gosu::Image.new(File.join(__dir__, "res", "ball.png"))
+  SPEED = 5
+
+  def initialize(**kw)
+    super(
+      # Our "animation" is just a single frame, so we can use the `Animation.static` helper to
+      # create it easily.
+      # We've named this animation `:normal` - these names are used to switch between animations
+      # later if you've got more than one.
+      # However, we don't need to worry about that here - the first animation is started by default
+      # when the entity is created.
+      animations: {
+        normal: Animation.static(IMAGE)
+      },
+      **kw
+    )
+
+    @velocity = [SPEED, SPEED]
+  end
+
+  # Override `#update` to implement our bouncy-ball logic by updating the entity's position
+  # (Remember to call `super`, or animations won't work as expected!)
+  def update
+    super
+
+    # Move the ball
+    position.x += @velocity[0]
+    position.y += @velocity[1]
+
+    # Bounce if we've hit left or right walls
+    # (`#image` retrives the current animation frame)
+    if position.x <= 0
+      @velocity[0] = SPEED
+    elsif position.x + image.width >= WIDTH
+      @velocity[0] = -SPEED
+    end
+
+    # Bounce if we've hit top or bottom walls
+    if position.y <= 0
+      @velocity[1] = SPEED
+    elsif position.y + image.height >= HEIGHT
+      @velocity[1] = -SPEED
+    end
+  end
+end
+
+# Now we can define our window - `OrangeZest::Window` is a subclass of `Gosu::Window` which makes
+# our life easier.
+class Game < OrangeZest::Window
+  def initialize
+    super WIDTH, HEIGHT
+
+    # Instantiate our components, and call `#register` to add them to the main group.
+    # Groups are components which can contain other components.
+    # Components fire in the order they are registered, so we must register `ClearScreen` first.
+    ClearScreen.new.register
+    BouncingBall.new(position: Point.new(50, 50)).register
+  end
+
+  # There's nothing else to do!
+  # We added our components to the main group, and one of the key things that `OrangeZest::Window` 
+  # does is to update and draw this group for us.
+  # The main group always exists and is the default for `#register`, but you can create more groups
+  # and manage them manually if you need to. `#register` can take a different group as an argument.
+end
+
+# Let's go!
+Game.new.show

data/examples/ui.rb

@@ -0,0 +1,43 @@
+require 'gosu'
+require 'orange_zest'
+
+include OrangeZest
+
+WIDTH = 640
+HEIGHT = 480
+
+class ClearScreen < Component
+  def draw
+    Gosu.draw_rect(0, 0, WIDTH, HEIGHT, Gosu::Color::WHITE)
+  end
+end
+
+class BouncingBall < Entity
+  IMAGE = Gosu::Image.new(File.join(__dir__, "res", "ball.png"))
+
+  include UI::Tooltip
+
+  def initialize(**kw)
+    super(animations: { normal: Animation.static(IMAGE) }, **kw)
+    @tooltip = "Hello"
+  end
+
+  def draw
+    super
+    draw_tooltip
+  end
+end
+
+class Game < OrangeZest::Window
+  def initialize
+    super WIDTH, HEIGHT
+
+    UI.default_font = Gosu::Font.new(16, name: "Arial")
+
+    ClearScreen.new.register
+    BouncingBall.new(position: Point.new(50, 50)).register
+  end
+end
+
+# Let's go!
+Game.new.show

data/lib/orange_zest/animation.rb

@@ -0,0 +1,52 @@
+module OrangeZest
+  # An animation which can be attached to an `Entity`.
+  class Animation
+    # The number of ticks to display each frame for. If -1, the current frame will be displayed
+    # forever.
+    # @return [Integer]
+    attr_accessor :ticks_per_image
+
+    # The images to cycle through as part of this animation.
+    # @return [<Gosu::Image>]
+    attr_accessor :images
+
+    def initialize(images, ticks_per_image)
+      @images = images
+      @ticks_per_image = ticks_per_image
+  
+      reset
+    end
+  
+    # A helper method to create an animation with a single static frame.
+    # @param [Gosu::Image] image
+    def self.static(image)
+      new([image], -1)
+    end
+
+    # Resets this animation to its first frame.
+    def reset
+      @ticks = 0
+      @image_idx = 0
+    end
+  
+    # Ticks this animation, advancing it to the next frame if enough ticks have passed.
+    # (Despite implementing this method, this is not a `Component`, as it does not make sense for
+    # it to exist on its own.)
+    def update
+      return if @ticks_per_image == -1
+  
+      @ticks += 1
+      if @ticks >= @ticks_per_image
+        @image_idx += 1
+        @image_idx %= @images.length
+        @ticks = 0
+      end
+    end
+  
+    # The current frame.
+    # @return [Gosu::Image]
+    def image
+      @images[@image_idx]
+    end
+  end
+end

data/lib/orange_zest/box.rb

@@ -0,0 +1,26 @@
+module OrangeZest
+  # A box, with an origin in the top-left corner.
+  class Box
+    def initialize(origin, width, height)
+      @origin = origin
+      @width = width
+      @height = height
+    end 
+
+    attr_accessor :origin, :width, :height
+
+    # Returns true if this box overlaps another box.
+    def overlaps?(other)
+      self.origin.x < other.origin.x + other.width \
+      && other.origin.x < self.origin.x + self.width \
+      && self.origin.y < other.origin.y + other.height \
+      && other.origin.y < self.origin.y + self.height
+    end
+
+    # Returns true if a point is inside this box.
+    def point_inside?(point)
+      point.x >= origin.x && point.x <= origin.x + width \
+      && point.y >= origin.y && point.y <= origin.y + height
+    end    
+  end 
+end

data/lib/orange_zest/component.rb

@@ -0,0 +1,32 @@
+module OrangeZest
+  # An object which can exist in the game world, and responds to Gosu's `#update` and `#draw`
+  # methods.
+  class Component
+    # The group which this component is registered with, if any.
+    # @return [Group, nil]
+    attr_reader :group
+
+    # Called during Gosu's update phase. A stub to be overridden.
+    def update; end
+
+    # Called during Gosu's draw phase. A stub to be overridden.
+    def draw; end
+
+    # Adds this component to a group. If no group is given, uses the `Main` group.
+    # Returns `self` so you can chain this with an assignment.
+    # @param [Group, nil] group
+    # @return [Component] Itself.
+    def register(group=nil)
+      group ||= Group::Main
+      group.add(self)
+      @group = group
+      self
+    end
+
+    # Removes this component from its group.
+    def unregister
+      raise 'tried to unregister component which is not registered' unless group
+      group.remove(self)
+    end
+  end
+end

data/lib/orange_zest/entity.rb

@@ -0,0 +1,88 @@
+require_relative 'animation'
+require_relative 'point'
+require_relative 'box'
+
+module OrangeZest
+  # A subclass of `Component` with associated size, position, and animation information.
+  class Entity < Component
+    # The position of this object.
+    # @return [Point]
+    attr_accessor :position
+    
+    # The animations which this object can perform.
+    # @return [{Object => Animation}]
+    attr_accessor :animations
+    
+    # The scaling of this entity.
+    # @return [Numeric]
+    attr_accessor :scaling
+    
+    # Whether this object should be mirrored along its X axis. Useful for flipping animations when
+    # creating a game with a 2D character.
+    # @return [Boolean]
+    attr_accessor :mirror_x
+    
+    # The rotation of this entity.
+    # @return [Numeric]
+    attr_accessor :rotation
+    
+    # The opacity of this entity. 255 is fully opaque, and 0 is fully transparent.
+    # @return [Integer]
+    attr_accessor :opacity
+
+    def initialize(position: nil, animations: nil, scaling: nil)
+      @position = position || Point.new(0, 0)
+      @animations = animations || {}
+      @scaling = scaling || 1
+      @rotation = 0
+      @opacity = 255
+
+      if animations.any?
+        @current_animation_name, @current_animation = animations.first
+      end
+
+      @mirror_x = false
+    end
+
+    # Retrieve the current frame of the currently-playing animation.
+    def image
+      @current_animation&.image
+    end
+
+    # Begin playing the animation with the given name, from the beginning.
+    # Raises an exception if an animation with that name does not exist in `#animations`.
+    # @param [Object] anim_name The name of the animation to begin, which should be a key in
+    #   `#animations`.
+    def animation=(anim_name)
+      return if @current_animation_name == anim_name
+
+      @current_animation = @animations[anim_name]
+      @current_animation_name = anim_name
+      raise "no animation named #{anim_name}" if !@current_animation
+
+      @current_animation.reset
+    end
+
+    def update
+      @current_animation&.update
+    end
+
+    def draw
+      return unless image
+
+      image.draw_rot(
+        position.x + (mirror_x ? image.width * scaling : 0), position.y, position.z,
+        rotation, 0, 0,
+        scaling * (mirror_x ? -1 : 1),
+        scaling,
+        Gosu::Color.new(opacity * 255, 255, 255, 255),
+      )
+    end
+
+    # Returns a bounding box for this entity, starting at its position and spanning the size of its
+    # current frame.
+    def bounding_box
+      Box.new(position, image.width, image.height)
+    end
+  end
+end

data/lib/orange_zest/group.rb

@@ -0,0 +1,49 @@
+require_relative 'component'
+
+module OrangeZest
+  # Wraps a collection of `Component`s into a single `Component`.
+  #
+  # The associated instance within this class, `Main`, is a special group available everywhere which
+  # components can be added to easily.
+  class Group < Component
+    # The items within this group.
+    # @return [<Component>]
+    attr_accessor :items
+
+    def initialize
+      @items = []
+      @enabled = true
+    end
+
+    # Whether to call `#update` or `#draw` on the items in this group. 
+    # @return [Boolean]
+    attr_accessor :enabled
+    alias enabled? enabled
+
+    # Adds a component to this group.
+    # @param [Component] component
+    def add(component)
+      @items << component
+    end
+    alias << add
+
+    # Removes a component from this group.
+    # @param [Component] component
+    def remove(component)
+      @items.delete(component)
+    end
+    alias delete remove
+
+    def update
+      return unless enabled?
+      items.each(&:update)
+    end
+
+    def draw
+      return unless enabled?
+      items.each(&:draw)
+    end
+
+    Main = new
+  end
+end

data/lib/orange_zest/input.rb

@@ -0,0 +1,37 @@
+module OrangeZest
+  # Holds some input state so that it can be globally accessed.
+  #
+  # In Gosu, the mouse cursor position is only available to the `Gosu::Window`, which makes it
+  # tricky to break the UI into components. This module stores and shares the cursor position for
+  # global access.
+  module Input
+    # Should be called from your `Gosu::Window#button_down` implementation. Updates `.click?`.
+    # @param [Integer] id The keycode pressed.
+    def self.button_down(id)
+      @click = (id == Gosu::MS_LEFT)
+    end
+
+    # Should be called from your `Gosu::Window'#update` implementation. Updates `.cursor`.
+    # @param [Gosu::Window] window The window this is being called from.
+    def self.update(window)
+      @cursor = Point.new(window.mouse_x, window.mouse_y)
+    end
+    
+    # The mouse cursor position within the window.
+    def self.cursor
+      @cursor
+    end
+
+    # Whether the left mouse button was clicked this frame. Even if the mouse is held down, this
+    # will only be `true` for the first frame of the click.
+    def self.click?
+      @click
+    end
+
+    # Clears the click registered this frame, if any. This can be used to ensure that a click is
+    # only seen by one UI element.
+    def self.clear_click
+      @click = false
+    end 
+  end
+end

data/lib/orange_zest/point.rb

@@ -0,0 +1,43 @@
+module OrangeZest
+  # A point in the game's world.
+  class Point
+    attr_accessor :x, :y, :z
+
+    def initialize(x, y, z = 0)
+      @x = x
+      @y = y
+      @z = z
+    end
+
+    def +(other)
+      raise "can't add point to #{other}" unless other.is_a?(Point)
+      Point.new(x + other.x, y + other.y, z + other.z)
+    end
+    
+    def -@
+      Point.new(-x, -y, -z)
+    end
+
+    def -(other)
+      self + -other
+    end
+
+    def ==(other)
+      other.is_a?(Point) &&
+        x == other.x &&
+        y == other.y &&
+        z == other.z
+    end
+
+    def hash
+      [x, y, z].hash
+    end
+
+    # Computes the distance between this point and another.
+    def distance(other)
+      x_dist = (x - other.x)
+      y_dist = (y - other.y)
+      Math.sqrt(x_dist**2 + y_dist**2)
+    end
+  end
+end

data/lib/orange_zest/scheduler.rb

@@ -0,0 +1,48 @@
+module OrangeZest
+  # Provides utilities for starting a task which persists across multiple updates. Tasks can suspend
+  # themselves for a fixed number of frames.
+  #
+  # The order in which resumed tasks run is not guaranteed. Tasks are not processes/threads and do
+  # not run asynchronously.
+  module Scheduler
+    @@pending = []
+
+    WaitResult = Struct.new('WaitResult', :time)
+
+    # Starts a new task, which executes the given block, and executes it until its first
+    # {Scheduler.wait} call.
+    #
+    # If a task terminates without ever waiting, an exception is thrown, since this is likely a bug.
+    def self.start(&block)
+      fiber = Fiber.new(&block)
+      result = fiber.resume
+      raise 'Scheduler task never waited' unless result.is_a?(WaitResult)
+      @@pending << [result.time, fiber]
+      nil
+    end
+
+    # Suspends the current task (started with {Scheduler.start}) for a given number of frames. 
+    # @param [Integer] ticks The number of frames to suspend for.
+    def self.wait(ticks)
+      Fiber.yield(WaitResult.new(ticks))
+    end
+
+    # Advance all suspended tasks by one frame. Called automatically by {OrangeZest::Window.update}.
+    def self.update
+      @@pending.map! do |(time, task)|
+        time = time - 1
+        if time <= 0
+          result = task.resume
+          if result.is_a?(WaitResult)
+            [result.time, task]
+          else
+            nil
+          end
+        else
+          [time, task]
+        end
+      end
+      @@pending.compact!
+    end
+  end
+end

data/lib/orange_zest/trigger_condition.rb

@@ -0,0 +1,39 @@
+module OrangeZest
+  # Allows wrapping a boolean condition to monitor it for changes.
+  module TriggerCondition
+    ON = :on
+    OFF = :off
+
+    @@states = {}
+    
+    # Watches the given boolean condition, and returns:
+    #
+    # - {TriggerCondition::ON} if the condition was previously false, and becomes true
+    # - {TriggerCondition::OFF} if the condition was previously true, and becomes false
+    # - `nil` if the condition has not changed
+    #
+    # Conditions are assumed to be false on the first call. 
+    #
+    # Each separate condition is identified by its source file and line number, which means you
+    # **must not watch more than one condition on a single line**.
+    #
+    # @param [Boolean] condition The condition to watch.
+    # @return The change in condition, if it has changed.
+    def self.watch(condition)
+      c = caller.first
+      triggered = @@states[c]
+      
+      if (!condition && !triggered) || (condition && triggered)
+        nil
+      elsif condition && !triggered
+        @@states[c] = true
+        TriggerCondition::ON
+      elsif !condition && triggered
+        @@states[c] = false
+        TriggerCondition::OFF
+      else
+        raise 'unexpected condition case'
+      end
+    end
+  end
+end

data/lib/orange_zest/ui/tooltip.rb

@@ -0,0 +1,43 @@
+module OrangeZest::UI
+  # A mixin which enables an object to show a tooltip when hovered.
+  #
+  # The object must have a method named `#bounding_box` which returns a `Box`. Then, your component
+  # should call `#draw_tooltip` during `#draw`, which will display the tooltip if the mouse cursor
+  # is within the bounding box.
+  module Tooltip
+    # An optional tooltip to display when the button is hovered. The tooltip may have multiple
+    # lines.
+    attr_accessor :tooltip
+
+    # Draws the tooltip if the object is being hovered. If a block is passed, the block is executed
+    # after the tooltip is drawn.
+    # @param [Gosu::Font, nil] font The font to use to draw the tooltip, or nil to use
+    #   `OrangeZest::UI.default_font`.
+    def draw_tooltip(font: nil, &block)
+      font = UI.default_font! unless font
+
+      if tooltip && bounding_box.point_inside?(Input.cursor)
+        # Find how tall the tooltip needs to be
+        lines = tooltip.split("\n")
+        text_width = lines.map { |l| font.text_width(l) }.max
+        text_height = lines.length * font.height
+
+        # Draw rectangle with some padding, clamp to edges of screen
+        padding = 10
+        origin_x = [Input.cursor.x, Window.current.width - (text_width + padding * 2)].min
+        origin_y = [Input.cursor.y, text_height + padding * 2].max
+        Gosu.draw_rect(
+          origin_x, origin_y - text_height - padding * 2,
+          text_width + padding * 2, text_height + padding * 2,
+          Gosu::Color.argb(0xDD, 0x00, 0x00, 0x00), 1000,
+        )
+        font.draw_text(
+          tooltip, origin_x + padding, origin_y - text_height - padding, 1000, 1, 1,
+          Gosu::Color::WHITE,
+        )
+
+        block&.()
+      end
+    end
+  end
+end

data/lib/orange_zest/ui.rb

@@ -0,0 +1,14 @@
+module OrangeZest
+  module UI
+    class << self
+      attr_accessor :default_font
+    end
+
+    def self.default_font!
+      raise "tried to fall back to default font, but none is set" if default_font.nil?
+      default_font
+    end
+  end
+end
+
+require_relative "ui/tooltip"

data/lib/orange_zest/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module OrangeZest
+  VERSION = "0.1.0"
+end

data/lib/orange_zest/window.rb

@@ -0,0 +1,33 @@
+module OrangeZest
+  # A subclass of `Gosu::Window` which overrides a variety of default methods in order to:
+  # - Draw and update the main group
+  # - Update and provide inputs to {OrangeZest::Input}
+  class Window < Gosu::Window
+    def self.current
+      @@current
+    end
+
+    def initialize(*args)
+      super(*args)
+      raise "OrangeZest only supports one window" if defined? @@current
+      @@current = self
+    end
+
+    def update
+      super
+      Input.update(self)
+      Scheduler.update
+      Group::Main.update
+    end
+
+    def draw
+      super
+      Group::Main.draw
+    end
+
+    def button_down(id)
+      super
+      Input.button_down(id)
+    end
+  end
+end

data/lib/orange_zest.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module OrangeZest; end
+
+require "gosu"
+
+require_relative "orange_zest/version"
+
+require_relative "orange_zest/component"
+require_relative "orange_zest/group"
+
+require_relative "orange_zest/box"
+require_relative "orange_zest/point"
+require_relative "orange_zest/entity"
+require_relative "orange_zest/scheduler"
+
+require_relative "orange_zest/input"
+require_relative "orange_zest/window"
+require_relative "orange_zest/trigger_condition"
+
+require_relative "orange_zest/ui"

data/orange_zest.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "lib/orange_zest/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "orange_zest"
+  spec.version       = OrangeZest::VERSION
+  spec.authors       = ["Aaron Christiansen"]
+  spec.email         = ["aaronc20000@gmail.com"]
+
+  spec.summary       = "A light wrapper for Gosu"
+  spec.homepage      = "http://github.com/AaronC81/orange_zest"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 2.4.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "gosu"
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: orange_zest
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aaron Christiansen
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-12-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gosu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- aaronc20000@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".github/workflows/main.yml"
+- ".gitignore"
+- ".rspec"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/basic.rb
+- examples/res/ball.png
+- examples/ui.rb
+- lib/orange_zest.rb
+- lib/orange_zest/animation.rb
+- lib/orange_zest/box.rb
+- lib/orange_zest/component.rb
+- lib/orange_zest/entity.rb
+- lib/orange_zest/group.rb
+- lib/orange_zest/input.rb
+- lib/orange_zest/point.rb
+- lib/orange_zest/scheduler.rb
+- lib/orange_zest/trigger_condition.rb
+- lib/orange_zest/ui.rb
+- lib/orange_zest/ui/tooltip.rb
+- lib/orange_zest/version.rb
+- lib/orange_zest/window.rb
+- orange_zest.gemspec
+homepage: http://github.com/AaronC81/orange_zest
+licenses:
+- MIT
+metadata:
+  homepage_uri: http://github.com/AaronC81/orange_zest
+  source_code_uri: http://github.com/AaronC81/orange_zest
+  changelog_uri: http://github.com/AaronC81/orange_zest/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: A light wrapper for Gosu
+test_files: []