rrb 0.0.4 → 0.0.5

data/lib/rrb/io/validation.rb

@@ -0,0 +1,105 @@
+# The IO module provides objects, modules, and functions to handle input/output operations.
+module RuneRb::IO
+
+  # A module used for validating data operations performed on buffer objects.
+  module Validation
+    class << self
+      include RuneRb::Utils::Logging
+
+      # Validates the passed parameters according to the options.
+      # @param buffer [Buffer] the buffer to validate against.
+      # @param operation [String] the operation to validate.
+      # @param params [Hash] a map of parameters to validate.
+      # @todo implement a ValidationError type to be raised when a validation fails.
+      def validate(buffer, operation, params = {})
+        return false unless valid_mode?(buffer, operation)
+        return false if buffer.mode.include?('w') && params[:bit_access] && !valid_access?(buffer, params[:bit_access])
+        return false if params[:mutation] && !valid_mutation?(params[:mutation])
+        return false if params[:order] && !valid_order?(params[:order])
+
+        true
+      end
+
+      # Reads data directly from an IO stream.
+      # @param io [Socket, IO] the IO object to read from.
+      # @param length [Integer] the amount of data to read
+      # @param buffer [Buffer] the buffer to read to.
+      def from_io(io, length, buffer)
+        raise 'Closed IO' if io.closed?
+
+        io.read_nonblock(length, buffer.data)
+      end
+
+      private
+
+      # Validates the current access mode for the write channel.
+      # @param buffer [Buffer] the buffer to validate against.
+      # @param required [Boolean] the access type required for the operation.
+      def valid_access?(buffer, required)
+        unless buffer.bit_access == required
+          err "Invalid access for operation! #{required} access is required for operation!"
+          return false
+        end
+        true
+      end
+
+      # Validates the operation with the current mode of the message.
+      # @param buffer [Buffer] the buffer to validate against.
+      # @param operation [String] the operation to validate.
+      def valid_mode?(buffer, operation)
+        return false if buffer.mode == 'r' && /(?i)\bpeek_write|write/.match?(operation)
+        return false if buffer.mode == 'w' && /(?i)\bpeek_read|read/.match?(operation)
+
+        true
+      end
+
+      # Validates the byte mutation for the operation
+      # @param mutation [String] the mutation that will be applied in the operation.
+      def valid_mutation?(mutation)
+        unless RuneRb::IO::BYTE_MUTATIONS.include?(mutation)
+          err "Unrecognized mutation! #{mutation}"
+          return false
+        end
+        true
+      end
+
+      # Validates the byte order to read for the operation
+      # @param order [String] the order in which to read bytes in the operation.
+      def valid_order?(order)
+        unless RuneRb::IO::BYTE_ORDERS.match?(order)
+          err "Unrecognized byte order! #{order}"
+          return false
+        end
+        true
+      end
+    end
+  end
+end
+
+# Copyright (c) 2022, Patrick W.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# * Neither the name of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/lib/rrb/io/writeable.rb

@@ -0,0 +1,236 @@
+# The IO module provides objects, modules, and functions to handle input/output operations.
+module RuneRb::IO
+
+  module Writeable
+    # Write data to the payload.
+    # @param type [Symbol] the type of value to write.
+    # @param value [Integer, String, Message, Array] the value to write.
+    def write(value, type: :byte, mutation: :STD, order: 'BIG', options: {})
+      return unless RuneRb::IO::Validation.validate(self, 'write', { mutation: mutation, order: order })
+
+      case type
+      when :bits then write_bits(value, options[:amount] || 1)
+      when :bit then write_bit(value)
+      when :byte then write_byte(value, mutation: mutation)
+      when :bytes then write_bytes(value)
+      when :short then write_short(value, mutation: mutation, order: order)
+      when :medium then write_medium(value, mutation: mutation, order: order)
+      when :int then write_int(value, mutation: mutation, order: order)
+      when :long then write_long(value, mutation: mutation, order: order)
+      when :smart then write_smart(value, mutation: mutation, signed: options[:signed] || false)
+      when :string then write_string(value)
+      when :reverse_bytes then write_reverse_bytes(value)
+      else raise "Unrecognized write type! #{type}"
+      end
+
+      self
+    end
+
+    # Enables or Disables bit writing by setting the {Buffer#bit_access} variable.
+    def switch_access
+      @bit_access = !@bit_access
+    end
+
+    def finish_access
+      @bit_position = (@bit_position + 7) / 8
+      switch_access
+    end
+
+    private
+
+    # Write a byte value to the payload.
+    # @param value [Integer] the byte value to write.
+    # @param mutation [String] mutations made to the byte.
+    def write_byte(value, mutation: :STD)
+      @data.concat([mutate(value, mutation)].pack('C'))
+    end
+
+    # Write a short value to the payload.
+    # @param value [Integer] the short value to write.
+    # @param mutation [String] the type of byte to write.
+    # @param order [String] the order in which bytes will be written.
+    def write_short(value, mutation: :STD, order: 'BIG')
+      case order
+      when 'BIG'
+        write_byte(value >> 8)
+        write_byte(value, mutation: mutation)
+      when 'LITTLE'
+        write_byte(value, mutation: mutation)
+        write_byte(value >> 8)
+      else raise "Unrecognized bit order: #{order}"
+      end
+    end
+
+    # Write a medium value to the payload.
+    # @param value [Integer] the medium value to write.
+    # @param mutation [String] the mutation made to the byte.
+    # @param order [String] the order in which bytes will be written.
+    def write_medium(value, mutation: :STD, order: 'BIG')
+      case order
+      when 'BIG'
+        write_byte(value >> 16)
+        write_byte(value >> 8)
+        write_byte(value, mutation: mutation)
+      when 'MIDDLE'
+        write_byte(value >> 8)
+        write_byte(value, mutation: mutation)
+        write_byte(value >> 16)
+      when 'LITTLE'
+        write_byte(value, mutation: mutation)
+        write_byte(value >> 8)
+        write_byte(value >> 16)
+      else raise "Unrecognized bit order: #{order}"
+      end
+    end
+
+    # Write a integer value to the payload.
+    # @param value [Integer] the integer value to write.
+    # @param mutation [String] the type of byte to write.
+    # @param order [String] the order in which bytes will be written.
+    def write_int(value, mutation: :STD, order: 'BIG')
+      case order
+      when 'BIG'
+        write_byte(value >> 24)
+        write_byte(value >> 16)
+        write_byte(value >> 8)
+        write_byte(value, mutation: mutation)
+      when 'MIDDLE'
+        write_byte(value >> 8)
+        write_byte(value, mutation: mutation)
+        write_byte(value >> 24)
+        write_byte(value >> 16)
+      when 'INVERSE_MIDDLE'
+        write_byte(value >> 16)
+        write_byte(value >> 24)
+        write_byte(value, mutation: mutation)
+        write_byte(value >> 8)
+      when 'LITTLE'
+        write_byte(value, mutation: mutation)
+        write_byte(value >> 8)
+        write_byte(value >> 16)
+        write_byte(value >> 24)
+      else raise "Unrecognized bit order: #{order}"
+      end
+    end
+
+    # Write a long value to the payload.
+    # @param value [Integer] the long value to write.
+    # @param mutation [String] the type of byte to write.
+    # @param order [String] the order in which bytes will be written.
+    def write_long(value, mutation: :STD, order: 'BIG')
+      case order
+      when 'BIG'
+        (RuneRb::IO::BYTE_SIZE * 7).downto(0) { |div| ((div % 8).zero? and div.positive?) ? write_byte(value >> div) : next }
+        write_byte(value, mutation: mutation)
+      when 'LITTLE'
+        write_byte(value, mutation: mutation)
+        (0).upto(RuneRb::IO::BYTE_SIZE * 7) { |div| ((div % 8).zero? and div.positive?) ? write_byte(value >> div) : next }
+      else raise "Unrecognized bit order: #{order}"
+      end
+    end
+
+    # Write a string value to the payload. This will be escaped/terminated with a \n[10] value.
+    # @param string [String] the byte to write to the payload.
+    def write_string(string)
+      @data.concat(string.force_encoding(Encoding::BINARY))
+      write_byte(10)
+    end
+
+    # Write a 'smart' value to the payload.
+    #
+    # @param value [Integer] the smart value to write.
+    # @param mutation [String] an optional mutation to apply to the written smart value.
+    def write_smart(value, mutation: :STD, signed: false)
+      case signed
+      when true
+        value > 128 ? write_byte(value, mutation: mutation) + 64 : write_short(value, mutation: mutation) + 49_152
+      when false
+        value > 128 ? write_byte(value, mutation: mutation) : write_short(value, mutation: mutation) + 32_768
+      end
+    end
+
+    # Writes multiple bytes to the payload.
+    # @param values [String, Array, RuneRb::IO::Buffer] the values whose bytes will be written.
+    def write_bytes(values)
+      case values
+      when Array then values.each { |byte| write_byte(byte.to_i) }
+      when RuneRb::IO::Message then @data.concat(values.body.data)
+      when RuneRb::IO::Buffer then @data.concat(values.data)
+      when String then @data.concat(values)
+      end
+    end
+
+    # Write a collection of bytes in reverse. *Not sure if I did this right.
+    # @param values [Array, String] the values to write.
+    def write_reverse_bytes(values)
+      case values
+      when Array then write(values.reverse, type: :bytes)
+      when String then write(values.bytes.reverse, type: :bytes)
+      end
+    end
+
+    # Write a single bit with a value of 1 or 0 depending on the flag parameter.
+    # @param flag [Boolean] the flag
+    def write_bit(flag)
+      write_bits(flag == true ? 1 : 0, 1)
+      self
+    end
+
+    # Write multiple bits to the payload
+    # @param amount [Integer] the amount of bits to occupy.
+    # @param value [Integer] the value to write.
+    def write_bits(value, amount)
+      byte_pos = @bit_position >> 3
+      bit_offset = 8 - (@bit_position & 7)
+      @bit_position += amount
+
+      while amount > bit_offset
+        @data[byte_pos] = [0].pack('c') if @data[byte_pos].nil?
+        @data[byte_pos] = [(@data[byte_pos].unpack1('c') & ~RuneRb::IO::BIT_MASK_OUT[bit_offset])].pack('c')
+        @data[byte_pos] = [(@data[byte_pos].unpack1('c') | (value >> (amount - bit_offset)) & RuneRb::IO::BIT_MASK_OUT[bit_offset])].pack('c')
+        byte_pos += 1
+        amount -= bit_offset
+        bit_offset = 8
+      end
+
+      @data[byte_pos] = [0].pack('c') if @data[byte_pos].nil?
+
+      if amount == bit_offset
+        @data[byte_pos] = [(@data[byte_pos].unpack1('c') & ~RuneRb::IO::BIT_MASK_OUT[bit_offset])].pack('c')
+        @data[byte_pos] = [(@data[byte_pos].unpack1('c') | (value & RuneRb::IO::BIT_MASK_OUT[bit_offset]))].pack('c')
+      else
+        @data[byte_pos] = [(@data[byte_pos].unpack1('c') & ~(RuneRb::IO::BIT_MASK_OUT[amount] << (bit_offset - amount)))].pack('c')
+        @data[byte_pos] = [(@data[byte_pos].unpack1('c') | ((value & RuneRb::IO::BIT_MASK_OUT[amount]) << (bit_offset - amount)))].pack('c')
+      end
+    end
+  end
+end
+
+
+# Copyright (c) 2022, Patrick W.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# * Neither the name of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/lib/rrb/utils/controller.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'rrb_data'
+require 'rrb_game'
+require 'rrb_net'
+
+# Utility objects and modules.
+module RuneRb::Utils
+
+  # The Controller instance facilitates the deployment of game world and server instances.
+  class Controller
+    using RuneRb::Patches::IntegerRefinements
+
+    include RuneRb::Utils::Logging
+
+    include Singleton
+
+    # @!attribute [r] sessions
+    # @return [Hash] a collection of sessions.
+    attr :sessions
+
+    # @!attribute [r] servers
+    # @return [Hash] a collection of server objects and signatures.
+    attr :servers
+
+    # @!attribute [r] worlds
+    # @return [Array] a map of World instances.
+    attr :worlds
+
+    # Constructs a new Controller object
+    def initialize
+      @worlds = {}
+      @start = { time: Process.clock_gettime(Process::CLOCK_MONOTONIC), stamp: Time.now }
+    end
+
+    def autorun
+      # Setup signal trapping
+      setup_trapping
+
+      # Deploy server process
+      deploy_server
+
+      # Deploy Game world
+      deploy_world
+
+      # Deploy Console
+      deploy_console
+    ensure
+      shutdown
+    end
+
+    # Logs information about the worlds, servers, and session states.
+    def about
+      log COLORS.cyan("[Server]:\n#{@server_pid.nil? ? COLORS.green.bold(@server_pid) : COLORS.red.bold('nil')}")
+      log COLORS.cyan("[World]:\n#{@world_pid.nil? ? COLORS.green.bold(@world_pid) : COLORS.red.bold('nil')}")
+    end
+
+    # Deploy a console session.
+    def deploy_console
+      Pry.start(self)
+    end
+
+    # Deploys a single TCP Socket Server.
+    # @return [Integer, NilClass] the process ID for the server process.
+    def deploy_server
+      @server_pid ||= Process.fork { RuneRb::Network::Server.instance.autorun }
+    end
+
+    # Deploys a single instance of {RuneRb::Game::World::Instance}
+    # @return [Integer, NilClass] the constructed World
+    def deploy_world
+      @world_pid ||= Process.fork { RuneRb::Game::World::Instance.instance }
+    end
+
+    # Stop all server instances and close all connected sessions.
+    def shutdown(graceful: true)
+      # Kill server process
+      Process.kill(graceful ? 'INT' : 'TERM', @server_pid) unless @server_pid.nil?
+
+      # Kill World processes
+      Process.kill(graceful ? 'INT' : 'TERM', @world_pid) unless @world_pid.nil?
+
+      # Log up-time
+      log! COLORS.blue.bold("Total Controller Up-time: #{up_time.to_i.to_ftime}")
+    ensure
+      exit!
+    end
+
+    # The current up-time for the server.
+    def up_time
+      (Process.clock_gettime(Process::CLOCK_MONOTONIC) - @start[:time]).round(3)
+    end
+
+    private
+
+    def setup_trapping
+      # Trap Interrupt (INT) signals.
+      Signal.trap('INT') do
+        Thread.new do
+          log! COLORS.red('Caught INTERRUPT!')
+          log! COLORS.red.bold('Shutting Down...')
+        ensure
+          shutdown
+        end.join
+      end
+
+      # Trap Termination (TERM) signals.
+      Signal.trap('TERM') do
+        Thread.new do
+          log! COLORS.red('Caught TERMINATION!')
+          log! COLORS.red.bold('Shutting Down...')
+        ensure
+          shutdown
+        end.join
+      end
+    end
+  end
+end
+
+# Copyright (c) 2021, Patrick W.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# * Neither the name of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/{app → lib}/rrb.rb

@@ -5,7 +5,6 @@ $LOAD_PATH.unshift File.dirname(__FILE__)
 
 require 'dotenv'
 require 'druuid'
-require 'eventmachine'
 require 'logger'
 require 'oj'
 require 'open-uri'
@@ -14,7 +13,6 @@ require 'pry'
 require 'singleton'
 require 'set'
 
-##
 # RuneRb -
 #  A gameserver framework written in Ruby targeting the 2006 era (or the 317-377 protocols) of the popular MMORPG, RuneScape.
 #
@@ -22,6 +20,35 @@ require 'set'
 # @since 0.0.1
 module RuneRb
 
+  # The IO module provides objects, modules, and functions to handle input/output operations.
+  module IO
+    # Acceptable byte orders in which multi-byte values can be read.
+    # @return [Array] the orders.
+    BYTE_ORDERS = /(?i)\bBIG|MIDDLE|INVERSE_MIDDLE|LITTLE/.freeze
+
+    # The size of a byte
+    # @type [Integer] the size
+    BYTE_SIZE = 8
+
+    # Valid byte mutations
+    # @return [Hash]
+    BYTE_MUTATIONS = %i[ADD NEG SUB STD].freeze
+
+    # Types that can be read.
+    RW_TYPES = %i[bits bit byte bytes medium int long reverse_bytes short smart string].freeze
+
+    # Bit masks for bit packing
+    # @return [Array]
+    BIT_MASK_OUT = (0...32).collect { |bit| (1 << bit) - 1 }
+
+    autoload :Buffer,                           'rrb/io/buffer'
+    autoload :Message,                          'rrb/io/message'
+    autoload :NativeReadable,                   'rrb/io/native_readable'
+    autoload :Readable,                         'rrb/io/readable'
+    autoload :Writeable,                        'rrb/io/writeable'
+    autoload :Validation,                       'rrb/io/validation'
+  end
+
   # Utility objects and modules.
   module Utils
     autoload :Controller,                       'rrb/utils/controller'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rrb
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Patrick W.
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-11 00:00:00.000000000 Z
+date: 2022-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dotenv
@@ -50,26 +50,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.2
-- !ruby/object:Gem::Dependency
-  name: eventmachine
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.2.7
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.2.7
 - !ruby/object:Gem::Dependency
   name: logger
   requirement: !ruby/object:Gem::Requirement
@@ -190,43 +170,49 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 13.0.0
-description:
+description: 
 email: Sickday@pm.me
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- app/rrb.rb
-- app/rrb/patches/integer.rb
-- app/rrb/patches/set.rb
-- app/rrb/patches/string.rb
-- app/rrb/utils/controller.rb
-- app/rrb/utils/environment.rb
-- app/rrb/utils/logging.rb
-- app/rrb/utils/version.rb
-homepage: https://git.repos.pw/rune.rb/app
+- lib/rrb.rb
+- lib/rrb/io/buffer.rb
+- lib/rrb/io/message.rb
+- lib/rrb/io/native_readable.rb
+- lib/rrb/io/readable.rb
+- lib/rrb/io/validation.rb
+- lib/rrb/io/writeable.rb
+- lib/rrb/patches/integer.rb
+- lib/rrb/patches/set.rb
+- lib/rrb/patches/string.rb
+- lib/rrb/utils/controller.rb
+- lib/rrb/utils/environment.rb
+- lib/rrb/utils/logging.rb
+- lib/rrb/utils/version.rb
+homepage: https://git.repos.pw/rune.rb/lib
 licenses:
 - BSD-3-Clause
 metadata:
-  source_code_uri: https://git.repos.pw/rune.rb/app
-post_install_message:
+  source_code_uri: https://git.repos.pw/rune.rb/lib
+post_install_message: 
 rdoc_options: []
 require_paths:
-- app
-- app/rrb
+- lib
+- lib/rrb
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.1
+      version: 2.7.5
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
-signing_key:
+rubygems_version: 3.3.7
+signing_key: 
 specification_version: 4
 summary: A gameserver framework written in Ruby targeting the 2006 era (or the 317-377
   protocols) of the popular MMORPG, RuneScape.