solargraph-dragonruby 0.2.0

data/stubs/extensions/layout.rb

@@ -0,0 +1,175 @@
+module GTK
+  class Layout
+    class << self
+      # @return [Integer] rows in the layout grid (`12` landscape, `24` portrait)
+      def row_count; end
+
+      # @return [Integer] maximum row index
+      def row_max_index; end
+
+      # @return [Integer] columns in the layout grid (`24` landscape, `12` portrait)
+      def col_count; end
+
+      # @return [Integer] maximum column index
+      def col_max_index; end
+
+      # Same as `Layout.rect(..., allscreen: true)`: the returned rect is
+      # aligned to `Grid.allscreen_rect` instead of the 16:9 safe area. Useful
+      # for layouts in render targets with `hd_letterbox=false`.
+      #
+      # Pro license (All Screen mode).
+      #
+      # @param row [Integer, Array(Integer, Integer)]
+      # @param col [Integer, Array(Integer, Integer)]
+      # @param w [Integer]
+      # @param h [Integer]
+      # @return [Typing::RectPropsHash] `x`, `y`, `w`, `h`, and `center` (a Hash with `x`, `y`)
+      def allscreen_rect row: 0, col: 0, w: 1, h: 1, **opts; end
+
+      # The rect of a cell span on the virtual grid (12 rows by 24 columns, or
+      # 24 by 12 in portrait), within the safe area.
+      #
+      # @example
+      #   Layout.rect(row: 1, col: 10, w: 4, h: 2)
+      #   Layout.rect(row: 0, col: [3, -3])   # columns 3 through the third from the right
+      #
+      # @param row [Numeric, Array(Integer, Integer)] row, or a `[from, to]` range (`to <= 0` counts from the end)
+      # @param col [Numeric, Array(Integer, Integer)] column, or a `[from, to]` range
+      # @param w [Numeric] width in cells
+      # @param h [Numeric] height in cells
+      # @param row_from_bottom [Numeric, nil] row counted from the bottom, instead of `row`
+      # @param col_from_right [Numeric, nil] column counted from the right, instead of `col`
+      # @param max_width [Numeric, nil]
+      # @param max_height [Numeric, nil]
+      # @param dx [Numeric] added to `x`
+      # @param dy [Numeric] added to `y`
+      # @param include_row_gutter [Boolean]
+      # @param include_col_gutter [Boolean]
+      # @param include_gutter [Boolean] both gutters
+      # @param merge [Hash, nil] merged into the result
+      # @param origin [Symbol]
+      # @param safe_area [Boolean]
+      # @param allscreen [Boolean] align to `Grid.allscreen_rect` (Pro license, All Screen mode)
+      # @return [Typing::RectPropsHash] `x`, `y`, `w`, `h`, and `center` (a Hash with `x`, `y`)
+      def rect row: 0, col: 0, w: 1, h: 1, row_from_bottom: nil, col_from_right: nil, max_width: nil, max_height: nil, dx: 0, dy: 0, include_row_gutter: false, include_col_gutter: false, include_gutter: false, merge: nil, origin: :top_left, safe_area: true, allscreen: false; end
+
+      # Lays out `items` one after another, wrapping at the edge of the grid.
+      # Each result is the item's rect merged with `item:` and `layout:`.
+      # An item may carry its own `rect_args` (`w`, `h`, gutters).
+      #
+      # @param items [Array]
+      # @param direction [Symbol] `:row` (left to right) or `:col` (top to bottom)
+      # @param row [Numeric] starting row
+      # @param col [Numeric] starting column
+      # @param w [Numeric] width of each item in cells
+      # @param h [Numeric] height of each item in cells
+      # @param include_row_gutter [Boolean]
+      # @param include_col_gutter [Boolean]
+      # @return [Array<Typing::RectPropsHash>]
+      def rects items, direction: :row, row: 0, col: 0, w: 1, h: 1, include_row_gutter: false, include_col_gutter: false; end
+
+      # Lays out each Hash in `group:` starting at `row:`/`col:` (or
+      # `row_from_bottom:`/`col_from_right:`), stepping by `drow:`/`dcol:`.
+      # Each result is the rect merged with the item (labels honor
+      # `alignment_enum`).
+      #
+      # @example
+      #   Layout.rect_group(row: 0, col: 0, drow: 0.5, group: [{ text: "a" }, { text: "b" }])
+      #
+      # @param group [Array<Hash>] items to lay out; each may have its own `layout:` rect options
+      # @param row [Numeric, nil] starting row
+      # @param col [Numeric, nil] starting column
+      # @param row_from_bottom [Numeric, nil] starting row counted from the bottom
+      # @param col_from_right [Numeric, nil] starting column counted from the right
+      # @param drow [Numeric] rows to move for each item
+      # @param dcol [Numeric] columns to move for each item
+      # @param w [Numeric] width of each item in cells
+      # @param h [Numeric] height of each item in cells
+      # @param merge [Hash, nil] merged into every result
+      # @param row_offset [Hash, nil] `count:` (and `h:`) of items to center vertically
+      # @param col_offset [Hash, nil] `count:` (and `w:`) of items to center horizontally
+      # @return [Array<Typing::RectPropsHash>]
+      def rect_group group:, row: nil, col: nil, row_from_bottom: nil, col_from_right: nil, drow: 0, dcol: 0, w: 0, h: 0, merge: nil, row_offset: nil, col_offset: nil; end
+
+      # A point inside a cell. `row_anchor:`/`col_anchor:` (`0.0` to `1.0`)
+      # pick where in the cell; the default is the cell's bottom left.
+      #
+      # @example
+      #   Layout.point(row: 7, col: 5.5, row_anchor: 0.5, col_anchor: 0.5)
+      #
+      # @param row [Numeric]
+      # @param col [Numeric]
+      # @param row_anchor [Float, nil] `0.0` (bottom) to `1.0` (top) of the cell
+      # @param col_anchor [Float, nil] `0.0` (left) to `1.0` (right) of the cell
+      # @param rect_options [Hash] other #rect options
+      # @return [Typing::RectPropsHash]
+      def point row: 0, col: 0, row_anchor: nil, col_anchor: nil, **rect_options; end
+
+      # @param reference [Typing::Rect, Object] rect to take the size from
+      # @param target [Typing::Rect, Object] rect to center on
+      # @return [Typing::RectHash] a rect the size of `reference` centered on `target`
+      def rect_center reference, target; end
+
+      # @param n [Numeric]
+      # @return [Numeric] width of `n` columns
+      def w n; end
+
+      # @param n [Numeric]
+      # @return [Numeric] height of `n` rows
+      def h n; end
+
+      # @return [Numeric] space between cells
+      def gutter; end
+
+      # @return [Numeric] size of a cell (cells are square)
+      def cell_size; end
+
+      # @return [Numeric] same as #cell_size
+      def cell_width; end
+
+      # @return [Numeric] same as #cell_size
+      def cell_height; end
+
+      # @return [Typing::RectHash] `x`, `y`, `w`, `h` of the area inside the outer gutters
+      def control_rect; end
+
+      # @return [Typing::RectHash] `x`, `y`, `w`, `h` of the safe area
+      def safe_rect; end
+
+      # @return [Typing::RectHash] `x`, `y`, `w`, `h` of the logical canvas
+      def logical_rect; end
+
+      # @return [Symbol] `:landscape` or `:portrait`
+      def orientation; end
+
+      # @return [Numeric] font size in points that fills a cell's height
+      def font_size_cell; end
+
+      # @return [Numeric] same as #font_size_cell
+      def font_size_xl; end
+
+      # @return [Numeric] 80% of #font_size_cell
+      def font_size_lg; end
+
+      # @return [Numeric] 70% of #font_size_cell
+      def font_size_med; end
+
+      # @return [Numeric] same as #font_size_med
+      def font_size; end
+
+      # @return [Numeric] 60% of #font_size_cell
+      def font_size_sm; end
+
+      # @return [Numeric] 50% of #font_size_cell
+      def font_size_xs; end
+
+      # @param px [Numeric]
+      # @return [Integer] `px` in points
+      def font_px_to_pt px; end
+
+      # @param pt [Numeric]
+      # @return [Numeric] `pt` in pixels
+      def font_pt_to_px pt; end
+    end
+  end
+end

data/stubs/extensions/log.rb

@@ -0,0 +1,158 @@
+# Logging functions available everywhere. Output goes to the console and
+# the log file.
+class Object
+  # Logs `args`, like `puts`.
+  #
+  # @return [void]
+  def log *args; end
+
+  # Logs `args` without a trailing newline.
+  #
+  # @return [void]
+  def log_print *args; end
+
+  # Logs `args` as an important, highlighted message.
+  #
+  # @return [void]
+  def log_important *args; end
+
+  # Logs `args` at the info level.
+  #
+  # @return [void]
+  def log_info *args; end
+
+  # Logs `args` at the error level.
+  #
+  # @return [void]
+  def log_error *args; end
+
+  # Logs `str` at the spam level.
+  #
+  # @param str [String]
+  # @param subsystem [String, nil]
+  # @return [void]
+  def log_spam str, subsystem = nil; end
+
+  # Logs `str` at the debug level.
+  #
+  # @param str [String]
+  # @param subsystem [String, nil]
+  # @return [void]
+  def log_debug str, subsystem = nil; end
+
+  # Logs `str` at the warn level.
+  #
+  # @param str [String]
+  # @param subsystem [String, nil]
+  # @return [void]
+  def log_warn str, subsystem = nil; end
+
+  # Logs `str` at the unfiltered level.
+  #
+  # @param str [String]
+  # @param subsystem [String, nil]
+  # @return [void]
+  def log_unfiltered str, subsystem = nil; end
+
+  # Logs `message` only the first time it's called with these `ids`.
+  #
+  # @example
+  #   log_once :low_health, "health is low"
+  #
+  # @param ids [Array<Symbol, String>]
+  # @param message [String]
+  # @param include_caller [Boolean] also log the backtrace
+  # @param raise_if [Boolean] raise `message` instead of logging it
+  # @return [void]
+  def log_once *ids, message, include_caller: false, raise_if: false; end
+
+  # Like #log_once, as an important message.
+  #
+  # @return [void]
+  def log_once_important *ids, message, include_caller: false; end
+
+  # Like #log_once, at the info level.
+  #
+  # @return [void]
+  def log_once_info *ids, message, include_caller: false; end
+
+  # Logs `args` in black.
+  #
+  # @return [void]
+  def log_black *args; end
+
+  # Logs `args` in red.
+  #
+  # @return [void]
+  def log_red *args; end
+
+  # Logs `args` in green.
+  #
+  # @return [void]
+  def log_green *args; end
+
+  # Logs `args` in yellow.
+  #
+  # @return [void]
+  def log_yellow *args; end
+
+  # Logs `args` in blue.
+  #
+  # @return [void]
+  def log_blue *args; end
+
+  # Logs `args` in magenta.
+  #
+  # @return [void]
+  def log_magenta *args; end
+
+  # Logs `args` in cyan.
+  #
+  # @return [void]
+  def log_cyan *args; end
+
+  # Logs `args` in white.
+  #
+  # @return [void]
+  def log_white *args; end
+
+  # Logs `args` in bright black.
+  #
+  # @return [void]
+  def log_bright_black *args; end
+
+  # Logs `args` in bright red.
+  #
+  # @return [void]
+  def log_bright_red *args; end
+
+  # Logs `args` in bright green.
+  #
+  # @return [void]
+  def log_bright_green *args; end
+
+  # Logs `args` in bright yellow.
+  #
+  # @return [void]
+  def log_bright_yellow *args; end
+
+  # Logs `args` in bright blue.
+  #
+  # @return [void]
+  def log_bright_blue *args; end
+
+  # Logs `args` in bright magenta.
+  #
+  # @return [void]
+  def log_bright_magenta *args; end
+
+  # Logs `args` in bright cyan.
+  #
+  # @return [void]
+  def log_bright_cyan *args; end
+
+  # Logs `args` in bright white.
+  #
+  # @return [void]
+  def log_bright_white *args; end
+end

data/stubs/extensions/main.rb

@@ -0,0 +1,63 @@
+# The recommended entry point for a game (see docs/api/runtime.md, "Main").
+# Functions defined in `Main` can call `args`, `inputs`, `outputs`, `state`,
+# `events` and `audio` directly, and the hooks don't need to take `args`.
+#
+# Defining `Main#tick` disables OpenEntity and Array primitives, so `state`
+# is a plain Hash (dot access like `state.score` still works).
+module Main
+  # Same object passed to top-level `tick args`.
+  # @return [GTK::Args]
+  attr_accessor :args
+
+  # Same as `args.inputs`.
+  # @return [GTK::Inputs]
+  def inputs; end
+
+  # Same as `args.outputs`.
+  # @return [GTK::Outputs]
+  def outputs; end
+
+  # Same as `args.state`. A plain Hash in `Main` (OpenEntity is disabled),
+  # retained across `tick` invocations and cleared by `DR.reset`.
+  # @return [Hash]
+  def state; end
+
+  # Same as `args.events`.
+  # @return [GTK::Events]
+  def events; end
+
+  # Same as `args.audio`.
+  # @return [AudioHash]
+  def audio; end
+
+  # Called once, at the very beginning of the process, for setup.
+  # @param args [GTK::Args]
+  # @return [void]
+  def boot args = nil; end
+
+  # Called before `tick` when `Kernel.tick_count == 0`. Only available in `Main`.
+  # @param args [GTK::Args]
+  # @return [void]
+  def start args = nil; end
+
+  # Called every frame (60 times a second). Takes precedence over a
+  # top-level `tick`.
+  # @param args [GTK::Args]
+  # @return [void]
+  def tick args = nil; end
+
+  # Called when `DR.reset` is invoked, before the reset happens.
+  # @param args [GTK::Args]
+  # @return [void]
+  def reset args = nil; end
+
+  # Called after DragonRuby's internal reset completes (see `reset`).
+  # @param args [GTK::Args]
+  # @return [void]
+  def did_reset args = nil; end
+
+  # Called before the game exits, and as part of `DR.reboot`.
+  # @param args [GTK::Args]
+  # @return [void]
+  def shutdown args = nil; end
+end