solargraph-dragonruby 0.2.0

data/stubs/extensions/zlib.rb

@@ -0,0 +1,24 @@
+# Compresses and uncompresses strings.
+module Zlib
+  class << self
+    # @param string [String]
+    # @return [String] compressed data
+    def compress string; end
+
+    # Same as #compress.
+    #
+    # @param string [String]
+    # @return [String]
+    def deflate string; end
+
+    # @param string [String] data returned by #compress
+    # @return [String] the original string
+    def uncompress string; end
+
+    # Same as #uncompress.
+    #
+    # @param string [String]
+    # @return [String]
+    def inflate string; end
+  end
+end

data/stubs/upstream/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Owen Butler
+
+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/stubs/upstream/UPSTREAM

@@ -0,0 +1,2 @@
+https://github.com/owenbutler/dragonruby-yard-doc
+06cc3d102017b726b3e5727510166f0f108eba27

data/stubs/upstream/args.rb

@@ -0,0 +1,61 @@
+module GTK
+  class Args
+    # @return [GTK::Inputs]
+    attr_reader :inputs
+
+    # @return [GTK::Outputs]
+    attr_reader :outputs
+
+    # Hash that contains audio sources that are playing.
+    #
+    # Sounds that don’t specify looping: true will be removed automatically from the hash after the playback ends. Looping sounds or sounds that should stop early must be removed manually.
+    #
+    # When you assign a hash to an audio output, a :length key will be added to the hash on the following tick. This will tell you the duration of the audio file in seconds (float).
+    #
+    # ## volume
+    #
+    # You can globally control the volume for all audio using args.audio.volume.
+    #
+    # ## One time sounds
+    # ```
+    # args.audio[:coin] = { input: "sounds/coin.wav" }
+    # ```
+    # ## Looping sounds
+    # ```
+    # args.audio[:bg_music] = { input: "sounds/bg-music.ogg", looping: true }
+    # ```
+    #
+    # see : [additional audio properties](https://docs.dragonruby.org/#/api/audio?id=setting-additional-audio-properties)
+    #
+    # @return [Hash]
+    attr_reader :audio
+
+    # @return [Module<GTK::Easing>]
+    attr_reader :easing
+
+    # @return [Module<GTK::Layout>]
+    attr_reader :layout
+
+    # @return [Module<GTK::Geometry>]
+    attr_reader :geometry
+
+    # Hash containing metadata pulled from the files under the ./metadata directory.
+    #
+    # Each CVar has the following properties `value, name, description, type, locked`.
+    #
+    # example:
+    #
+    # ```
+    # def tick args
+    #   args.outputs.labels << {
+    #   x: 640,
+    #   y: 360,
+    #   text: args.cvars["game_metadata.version"].value.to_s
+    #   }
+    # end
+    # ```
+    #
+    # @return [Hash] Hash containing metadata pulled from the files under the ./metadata directory.
+    attr_reader :cvars
+  end
+end

data/stubs/upstream/constants.rb

@@ -0,0 +1,8 @@
+# @type [Module<GTK::Geometry>]
+Geometry = GTK::Geometry
+
+# @type [Class<GTK::Layout>]
+Layout = GTK::Layout
+
+# @type [Module<GTK::Easing>]
+Easing = GTK::Easing

data/stubs/upstream/controller.rb

@@ -0,0 +1,90 @@
+module GTK
+  class Controller
+    # @return [Boolean] Returns true if a controller is connected. If this value is false, controller properties will not be nil, but return 0 for directional based properties and false button state properties.
+    attr_reader :connected
+
+    # @return [String] String value representing the controller’s name.
+    attr_reader :name
+
+    # @return [Boolean] Returns true if any of the controller’s buttons were used.
+    attr_reader :active
+
+    # @return [Boolean] Returns true if up is pressed or held on the directional or left analog.
+    attr_reader :up
+
+    # @return [Boolean] Returns true if down is pressed or held on the directional or left analog.
+    attr_reader :down
+
+    # @return [Boolean] Returns true if left is pressed or held on the directional or left analog.
+    attr_reader :left
+
+    # @return [Boolean] Returns true if right is pressed or held on the directional or left analog.
+    attr_reader :right
+
+    # @return [Integer] Returns -1 (left), 0 (neutral), or +1 (right) depending on results of #left, #right
+    attr_reader :left_right
+
+    # @return [Integer] Returns -1 (left), 0 (neutral), or +1 (right) depending on results of #up, #down
+    attr_reader :up_down
+
+    # @return [Integer] Returns the raw integer value for the analog’s horizontal movement (-32,767 to +32,767).
+    attr_reader :left_analog_x_raw, :right_analog_x_raw
+
+    # @return [Integer] Returns the raw integer value for the analog’s vertical movement (-32,767 to +32,767).
+    attr_reader :left_analog_y_raw, :right_analog_y_raw
+
+    # @return [Float] Returns a number between -1 and 1 which represents the percentage the analog is moved horizontally as a ratio of the maximum horizontal movement.
+    attr_reader :left_analog_x_perc, :right_analog_x_perc
+
+    # @return [Float] Returns a number between -1 and 1 which represents the percentage the analog is moved vertically as a ratio of the maximum vertical movement.
+    attr_reader :left_analog_y_perc, :right_analog_y_perc
+
+    # @return [Boolean] Returns true if up is pressed or held on the dpad.
+    attr_reader :dpad_up, :directional_up
+
+    # @return [Boolean] Returns true if down is pressed or held on the dpad.
+    attr_reader :dpad_down, :directional_down
+
+    # @return [Boolean] Returns true if left is pressed or held on the dpad.
+    attr_reader :dpad_left, :directional_left
+
+    # @return [Boolean] Returns true if right is pressed or held on the dpad.
+    attr_reader :dpad_right, :directional_right
+
+    # @return [Boolean] Returns true if the specific button is pressed or held.
+    attr_reader :a, :b, :x, :y, :l1, :r1, :l2, :r2, :l3, :r3, :start, :select
+
+    # @ return [Object] Returns a collection of Symbols that represent all keys that are in the pressed or held state.
+    attr_reader :truthy_keys
+
+    # @return [Boolean] Returns true if the specific button was pressed on this frame.
+    #   button can be one of: (a|b|x|y|l1|r1|l2|r2|l3|r3|start|select)
+    #   result will only be true on the frame it was pressed.
+    attr_reader :key_down
+
+    # @return [Boolean] Returns true if the specific button is being held.
+    #   button can be one of: (a|b|x|y|l1|r1|l2|r2|l3|r3|start|select)
+    #   result will be true for all frames after key_down (until released)
+    attr_reader :key_held
+
+    # @return [Boolean] Returns true if the specific button was pressed on this frame.
+    #   button can be one of: (a|b|x|y|l1|r1|l2|r2|l3|r3|start|select)
+    #   result will only be true on the frame it was pressed.
+    attr_reader :key_up
+
+    # Returns true if the Left Analog Stick is tilted.
+    # The threshold_raw and threshold_perc are optional parameters that can be used to set the minimum threshold for the analog stick to be considered active.
+    # The threshold_raw is a number between 0 and 32,767, and the threshold_perc is a number between 0 and 1.
+    #
+    # @return [Boolean] Returns true if the Left Analog Stick is tilted.
+    def left_analog_active? threshold_raw, threshold_perc; end
+
+    # Returns true if the Right Analog Stick is tilted.
+    # The threshold_raw and threshold_perc are optional parameters that can be used to set the minimum threshold for the analog stick to be considered active.
+    # The threshold_raw is a number between 0 and 32,767, and the threshold_perc is a number between 0 and 1.
+    #
+    # @return [Boolean] Returns true if the Right Analog Stick is tilted.
+    def right_analog_active? threshold_raw, threshold_perc; end
+
+  end
+end

data/stubs/upstream/easing.rb

@@ -0,0 +1,119 @@
+module GTK
+  # A set of functions that allow you to determine the current progression of an easing function.
+  module Easing
+    class << self
+      # Given a start, current, duration, and a multiple bezier values, this function returns a number between 0 and 1 that represents the progress of an easing function.
+      #
+      # @param start_tick [Integer]
+      # @param current_tick [Integer]
+      # @param duration [Integer] duration in ticks
+      # @param spline [Array] multiple bezier values
+      # @return [Float] returns a number between 0 and 1 that represents the progress of an easing function.
+      def ease_spline start_tick, current_tick, duration, spline; end
+
+      # Given a start, current, duration, and easing definitions.  This function returns a number between 0 and 1 that represents the progress of an easing function.
+      #
+      # @param start_tick [Integer]
+      # @param current_tick [Integer]
+      # @param duration [Integer] duration in ticks
+      # @param definitions [Object] easing definitions
+      # @return [Float] returns a number between 0 and 1 that represents the progress of an easing function.
+      def ease start_tick, current_tick, duration, definitions; end
+
+      # smooth_start
+      #
+      # @param :initial [Float] starting value of the easing function (defaults to 0.0).
+      # @param :final [Float] ending value of the easing function (defaults to 1.0).
+      # @param :perc [Float] current easing percentage (a value over 1.0 will result in a higher final value).
+      # @param :power [float] 1 for linear, 2 for quadratic, 3 for cube, etc (defaults to 1.0).
+      # @return [Float] value between 0 and 1 that represents a percentage.
+      def smooth_start initial, final, perc, power; end
+
+      # smooth_start
+      #
+      # @param :start_at [Integer] starting tick_count to begin the easing function .
+      # @param :end_at [Integer] ending value of the easing function.
+      # @param :tick_count [Integer] current tick_count (defaults to Kernel.tick_count)
+      # @param :power [float] 1 for linear, 2 for quadratic, 3 for cube, etc (defaults to 1.0).
+      # @return [Float] value between 0 and 1 that represents a percentage.
+      def smooth_start start_at, end_at, tick_count, power; end
+
+      # smooth_start
+      #
+      # @param :start_at [Integer] starting tick_count to begin the easing function .
+      # @param :duration [Integer] used to compute end_at value.
+      # @param :tick_count [Integer] current tick_count (defaults to Kernel.tick_count)
+      # @param :power [float] 1 for linear, 2 for quadratic, 3 for cube, etc (defaults to 1.0).
+      # @return [Float] value between 0 and 1 that represents a percentage.
+      def smooth_start start_at, duration, tick_count, power; end
+
+      # smooth_stop
+      #
+      # @param :initial [Float] starting value of the easing function (defaults to 0.0).
+      # @param :final [Float] ending value of the easing function (defaults to 1.0).
+      # @param :perc [Float] current easing percentage (a value over 1.0 will result in a higher final value).
+      # @param :power [float] 1 for linear, 2 for quadratic, 3 for cube, etc (defaults to 1.0).
+      # @return [Float] value between 0 and 1 that represents a percentage.
+      def smooth_stop initial, final, perc, power; end
+
+      # smooth_stop
+      #
+      # @param :start_at [Integer] starting tick_count to begin the easing function .
+      # @param :end_at [Integer] ending value of the easing function.
+      # @param :tick_count [Integer] current tick_count (defaults to Kernel.tick_count)
+      # @param :power [float] 1 for linear, 2 for quadratic, 3 for cube, etc (defaults to 1.0).
+      # @return [Float] value between 0 and 1 that represents a percentage.
+      def smooth_stop start_at, end_at, tick_count, power; end
+
+      # smooth_stop
+      #
+      # @param :start_at [Integer] starting tick_count to begin the easing function .
+      # @param :duration [Integer] used to compute end_at value.
+      # @param :tick_count [Integer] current tick_count (defaults to Kernel.tick_count)
+      # @param :power [float] 1 for linear, 2 for quadratic, 3 for cube, etc (defaults to 1.0).
+      # @return [Float] value between 0 and 1 that represents a percentage.
+      def smooth_stop start_at, duration, tick_count, power; end
+
+      # smooth_step
+      #
+      # @param :initial [Float] starting value of the easing function (defaults to 0.0).
+      # @param :final [Float] ending value of the easing function (defaults to 1.0).
+      # @param :perc [Float] current easing percentage (a value over 1.0 will result in a higher final value).
+      # @param :power [float] 1 for linear, 2 for quadratic, 3 for cube, etc (defaults to 1.0).
+      # @return [Float] value between 0 and 1 that represents a percentage.
+      def smooth_step initial, final, perc, power; end
+
+      # smooth_step
+      #
+      # @param :start_at [Integer] starting tick_count to begin the easing function .
+      # @param :end_at [Integer] ending value of the easing function.
+      # @param :tick_count [Integer] current tick_count (defaults to Kernel.tick_count)
+      # @param :power [float] 1 for linear, 2 for quadratic, 3 for cube, etc (defaults to 1.0).
+      # @return [Float] value between 0 and 1 that represents a percentage.
+      def smooth_step start_at, end_at, tick_count, power; end
+
+      # smooth_step
+      #
+      # @param :start_at [Integer] starting tick_count to begin the easing function .
+      # @param :duration [Integer] used to compute end_at value.
+      # @param :tick_count [Integer] current tick_count (defaults to Kernel.tick_count)
+      # @param :power [float] 1 for linear, 2 for quadratic, 3 for cube, etc (defaults to 1.0).
+      # @return [Float] value between 0 and 1 that represents a percentage.
+      def smooth_step start_at, duration, tick_count, power; end
+
+      # Return a mixture of eased values.
+      #
+      # ```
+      # \# a 50/50 mix of smooth_start and smooth_stop gives us a smooth_step
+      # y_perc = Easing.mix(smoothed_start, smoothed_stop, 0.5)
+      # ```
+      # 
+      # See [More Detailed example](https://docs.dragonruby.org/#/api/easing?id=mix)
+      #
+      # @param val_1 [Float] first value to mix.
+      # @param val_2 [Float] second value to mix.
+      # @param perc [Float] mix percentage.
+      def mix val_1, val_2, perc; end
+    end
+  end
+end