solargraph-dragonruby 0.2.0

data/stubs/extensions/attr.rb

@@ -0,0 +1,249 @@
+# Class macros from dragon/attr_dr.rb, attr_sprite.rb, attr_label.rb and
+# attr_line.rb. Each one includes a module into the class it's called in. The
+# plugin's MacroNode adds those includes for calls in your game's code, so the
+# module methods complete on `self` and on instances.
+
+class ::Module
+  # Class macro that includes AttrDR, adding DragonRuby's environment methods
+  # (`args`, `state`, `inputs`, `outputs`, `audio`, `grid`, `events`, ...) to
+  # instances of the class, so `args` doesn't have to be passed around. Set
+  # `instance.args = args` before using them.
+  #
+  # @return [void]
+  def attr_dr; end
+
+  # Older name for #attr_dr.
+  # @return [void]
+  def attr_gtk; end
+
+  # Class macro that includes AttrSprite, so instances can be pushed into
+  # `args.outputs.sprites` (or `args.outputs.primitives`) directly.
+  #
+  # @return [void]
+  def attr_sprite; end
+
+  # Class macro that includes AttrRect: `left`/`right`/`top`/`bottom` and the
+  # Geometry functions, for a class that defines `x`, `y`, `w` and `h`.
+  #
+  # @return [void]
+  def attr_rect; end
+
+  # Class macro that includes AttrLabel, adding accessors for the label
+  # properties (`x`, `y`, `text`, `size_px`, `font`, ...).
+  #
+  # @return [void]
+  def attr_label; end
+
+  # Class macro that includes AttrLine, so instances can be pushed into
+  # `args.outputs.lines` (or `args.outputs.primitives`) directly.
+  #
+  # @return [void]
+  def attr_line; end
+end
+
+# Added to a class by `attr_dr` (or `attr_gtk`). Every method reads from
+# `args`, which must be assigned first.
+module AttrDR
+  # @return [GTK::Args]
+  attr_accessor :args
+
+  # Same as `args.inputs.keyboard`.
+  # @return [GTK::Keyboard]
+  def keyboard; end
+
+  # Same as `args.grid`.
+  # @return [GTK::Grid]
+  def grid; end
+
+  # Same as `args.state`.
+  # @return [GTK::OpenEntity]
+  def state; end
+
+  # Same as `args.temp_state`, which is cleared every tick.
+  # @return [GTK::OpenEntity]
+  def temp_state; end
+
+  # Same as `args.inputs`.
+  # @return [GTK::Inputs]
+  def inputs; end
+
+  # Same as `args.outputs`.
+  # @return [GTK::Outputs]
+  def outputs; end
+
+  # Same as `args.gtk`.
+  # @return [GTK::Runtime]
+  def gtk; end
+
+  # Same as `args.passes`.
+  # @return [Array]
+  def passes; end
+
+  # Same as `args.pixel_arrays`.
+  # @return [Hash{Symbol => GTK::PixelArray}]
+  def pixel_arrays; end
+
+  # Same as `args.geometry`.
+  # @return [Module<GTK::Geometry>]
+  def geometry; end
+
+  # Same as `args.layout`.
+  # @return [Module<GTK::Layout>]
+  def layout; end
+
+  # Same as `args.easing`.
+  # @return [Module<GTK::Easing>]
+  def easing; end
+
+  # Same as `args.audio`.
+  # @return [AudioHash]
+  def audio; end
+
+  # Same as `args.events`.
+  # @return [GTK::Events]
+  def events; end
+
+  # Same as `args.cvars`.
+  # @return [Hash]
+  def cvars; end
+
+  # Same as `state.new_entity`.
+  #
+  # @param entity_type [Symbol]
+  # @param init_hash [Hash, nil] initial property values
+  # @yieldparam entity [GTK::OpenEntity]
+  # @return [GTK::OpenEntity]
+  def new_entity entity_type, init_hash = nil, &block; end
+
+  # Same as `state.new_entity_strict`.
+  #
+  # @param entity_type [Symbol]
+  # @param init_hash [Hash, nil] the allowed properties and their initial values
+  # @yieldparam entity [GTK::StrictEntity]
+  # @return [GTK::StrictEntity]
+  def new_entity_strict entity_type, init_hash = nil, &block; end
+
+  # Same as `Kernel.tick_count`.
+  # @return [Integer]
+  def tick_count; end
+
+  # Same as `Kernel.global_tick_count`.
+  # @return [Integer]
+  def global_tick_count; end
+end
+
+# Older name for AttrDR.
+AttrGTK = AttrDR
+
+# Added to a class by `attr_rect` (and by `attr_sprite`). Expects the class to
+# respond to `x`, `y`, `w` and `h`.
+module AttrRect
+  include Typing::GeometryMixin
+
+  # @return [Numeric] same as `x`
+  def left; end
+
+  # @return [Numeric] `x + w`
+  def right; end
+
+  # @return [Numeric] same as `y`
+  def bottom; end
+
+  # @return [Numeric] `y + h`
+  def top; end
+
+  # @return [Numeric] same as `x`
+  def x1; end
+
+  # @return [Numeric] same as `y`
+  def y1; end
+end
+
+# Added to a class by `attr_sprite`. Instances render as sprites.
+module AttrSprite
+  include AttrRect
+
+  # @return [Numeric]
+  attr_accessor :x, :y, :w, :h, :z, :angle, :angle_x, :angle_y,
+    :angle_anchor_x, :angle_anchor_y, :anchor_x, :anchor_y,
+    :tile_x, :tile_y, :tile_w, :tile_h,
+    :source_x, :source_y, :source_w, :source_h,
+    :x2, :y2, :x3, :y3, :source_x2, :source_y2, :source_x3, :source_y3
+
+  # @return [Integer] 0-255
+  attr_accessor :r, :g, :b, :a, :r2, :g2, :b2, :a2, :r3, :g3, :b3, :a3
+
+  # @return [String, Symbol] image file path, or a render target name
+  attr_accessor :path
+
+  # @return [Boolean]
+  attr_accessor :flip_horizontally, :flip_vertically
+
+  # @return [Integer]
+  attr_accessor :blendmode_enum, :scale_quality_enum
+
+  # @return [Symbol, Integer]
+  attr_accessor :blendmode
+
+  # @return [Object]
+  attr_accessor :id
+
+  # @return [Symbol] always `:sprite`
+  def primitive_marker; end
+
+  # @return [self]
+  def sprite; end
+
+  # @param value [Numeric]
+  # @return [void]
+  def x1= value; end
+
+  # @param value [Numeric]
+  # @return [void]
+  def y1= value; end
+
+  # @return [Hash] the sprite properties
+  def serialize; end
+end
+
+# Added to a class by `attr_label`.
+module AttrLabel
+  # @return [Numeric]
+  attr_accessor :x, :y, :z, :anchor_x, :anchor_y, :size_px
+
+  # @return [String]
+  attr_accessor :text
+
+  # @return [Integer]
+  attr_accessor :size_enum, :alignment_enum, :vertical_alignment_enum, :blendmode_enum
+
+  # @return [Integer] 0-255
+  attr_accessor :r, :g, :b, :a
+
+  # @return [String] font file path
+  attr_accessor :font
+end
+
+# Added to a class by `attr_line`. Instances render as lines.
+module AttrLine
+  # @return [Numeric]
+  attr_accessor :x, :y, :x2, :y2, :w, :h
+
+  # @return [Integer] 0-255
+  attr_accessor :r, :g, :b, :a
+
+  # @return [Integer]
+  attr_accessor :blendmode_enum
+
+  # @return [Numeric] same as `x`
+  attr_accessor :x1
+
+  # @return [Numeric] same as `y`
+  attr_accessor :y1
+
+  # @return [Symbol] always `:line`
+  def primitive_marker; end
+
+  # @return [self]
+  def line; end
+end

data/stubs/extensions/easing.rb

@@ -0,0 +1,90 @@
+module GTK
+  module Easing
+    class << self
+      # Progress along a series of 4-point bezier curves, each given an equal
+      # share of `duration`.
+      #
+      # @example linear out and back
+      #   Easing.spline 10, Kernel.tick_count, 300, [[0, 0.25, 0.75, 1.0], [1.0, 0.75, 0.25, 0]]
+      #
+      # @param start_tick [Integer]
+      # @param current_tick [Integer]
+      # @param duration [Integer] duration in ticks
+      # @param spline [Array<Array<Numeric>>] bezier definitions, four values each
+      # @return [Float] the value on the curve; the last point of the spline once `duration` has passed
+      def spline start_tick, current_tick, duration, spline; end
+
+      # Progress (`0.0` to `1.0`) of chained easing definitions over `duration`.
+      #
+      # @example
+      #   Easing.ease 60, Kernel.tick_count, 120, :smooth_stop_quad
+      #
+      # @param start_tick [Integer]
+      # @param current_tick [Integer]
+      # @param duration [Integer] duration in ticks
+      # @param definitions [Array<Symbol, Proc>] `:identity`, `:flip`, `:quad`, `:cube`, `:quart`, `:quint`,
+      #   `:smooth_start_quad`, `:smooth_stop_quad`, ..., or lambdas taking `x`
+      # @return [Float]
+      def ease start_tick, current_tick, duration, *definitions; end
+
+      # Same as #spline.
+      #
+      # @param start_tick [Integer]
+      # @param current_tick [Integer]
+      # @param duration [Integer] duration in ticks
+      # @param spline [Array<Array<Numeric>>] bezier definitions, four values each
+      # @return [Float]
+      def ease_spline start_tick, current_tick, duration, spline; end
+
+      # Accelerating ease (`perc ** power`). Pass either
+      # `initial:`, `final:`, `perc:` or `start_at:` with `end_at:` or `duration:`.
+      #
+      # @example percentage-based
+      #   Easing.smooth_start initial: 0, final: 1280, perc: 0.5, power: 2
+      # @example time-based
+      #   Easing.smooth_start start_at: 60, duration: 120, power: 3
+      #
+      # @param initial [Float, nil] starting value
+      # @param final [Float, nil] ending value
+      # @param perc [Float, nil] current percentage (over `1.0` overshoots `final`)
+      # @param start_at [Integer, nil] tick the easing starts
+      # @param end_at [Integer, nil] tick the easing ends
+      # @param duration [Integer, nil] ticks from `start_at` to the end
+      # @param tick_count [Integer, nil] current tick (defaults to `Kernel.tick_count`)
+      # @param power [Numeric] `1` linear, `2` quadratic, `3` cubic, ...
+      # @param flip [Boolean] return `1 - result` (go from 1 to 0)
+      # @return [Float]
+      def smooth_start initial: nil, final: nil, perc: nil, start_at: nil, end_at: nil, duration: nil, tick_count: nil, power: 1, flip: false; end
+
+      # Decelerating ease (`1 - (1 - perc) ** power`). Takes the same
+      # arguments as #smooth_start.
+      #
+      # @param initial [Float, nil] starting value
+      # @param final [Float, nil] ending value
+      # @param perc [Float, nil] current percentage (over `1.0` overshoots `final`)
+      # @param start_at [Integer, nil] tick the easing starts
+      # @param end_at [Integer, nil] tick the easing ends
+      # @param duration [Integer, nil] ticks from `start_at` to the end
+      # @param tick_count [Integer, nil] current tick (defaults to `Kernel.tick_count`)
+      # @param power [Numeric] `1` linear, `2` quadratic, `3` cubic, ...
+      # @param flip [Boolean] return `1 - result` (go from 1 to 0)
+      # @return [Float]
+      def smooth_stop initial: nil, final: nil, perc: nil, start_at: nil, end_at: nil, duration: nil, tick_count: nil, power: 1, flip: false; end
+
+      # 50/50 mix of #smooth_start and #smooth_stop. Takes the same arguments
+      # as #smooth_start.
+      #
+      # @param initial [Float, nil] starting value
+      # @param final [Float, nil] ending value
+      # @param perc [Float, nil] current percentage (over `1.0` overshoots `final`)
+      # @param start_at [Integer, nil] tick the easing starts
+      # @param end_at [Integer, nil] tick the easing ends
+      # @param duration [Integer, nil] ticks from `start_at` to the end
+      # @param tick_count [Integer, nil] current tick (defaults to `Kernel.tick_count`)
+      # @param power [Numeric] `1` linear, `2` quadratic, `3` cubic, ...
+      # @param flip [Boolean] return `1 - result` (go from 1 to 0)
+      # @return [Float]
+      def smooth_step initial: nil, final: nil, perc: nil, start_at: nil, end_at: nil, duration: nil, tick_count: nil, power: 1, flip: false; end
+    end
+  end
+end

data/stubs/extensions/entity.rb

@@ -0,0 +1,63 @@
+module Typing
+  # phantom type for the properties every DragonRuby entity has
+  module Entity
+    # @return [Integer] automatically assigned id
+    attr_reader :entity_id
+
+    # @return [Symbol, nil]
+    attr_reader :entity_type
+
+    # @return [Integer] `Kernel.tick_count` when the entity was created
+    attr_reader :created_at
+
+    # @return [Integer] ticks elapsed since creation
+    def created_at_elapsed; end
+
+    # @return [Integer] `Kernel.global_tick_count` when the entity was created
+    attr_reader :global_created_at
+
+    # @return [Integer] global ticks elapsed since creation
+    def global_created_at_elapsed; end
+
+    # @return [Hash] the entity cast to a `Hash`, so values can be updated as if it were a `Hash`
+    def as_hash; end
+  end
+end
+
+module GTK
+  # Backing type of `args.state`. Any property can be read or assigned
+  # (`args.state.player.x ||= 0`); only the built-in ones are listed here.
+  class OpenEntity
+    include Typing::Entity
+
+    # @return [Integer] the current tick of the game (same as `Kernel.tick_count`)
+    def tick_count; end
+
+    # Creates a new entity that accepts arbitrary properties.
+    #
+    # @example
+    #   args.state.bullets << args.state.new_entity(:bullet) do |b|
+    #     b.x = 0
+    #   end
+    #
+    # @param entity_type [Symbol]
+    # @param init_hash [Hash, nil] initial property values
+    # @yieldparam entity [GTK::OpenEntity]
+    # @return [GTK::OpenEntity]
+    def new_entity entity_type, init_hash = nil, &block; end
+
+    # Creates a new entity that only allows the properties given in `init_hash`.
+    #
+    # @param entity_type [Symbol]
+    # @param init_hash [Hash, nil] the allowed properties and their initial values
+    # @yieldparam entity [GTK::StrictEntity]
+    # @return [GTK::StrictEntity]
+    def new_entity_strict entity_type, init_hash = nil, &block; end
+  end
+
+  # Entity returned by `new_entity_strict`; only the properties it was created
+  # with can be read or assigned.
+  class StrictEntity
+    include Typing::Entity
+  end
+end