rrb-common 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 339ea3353a55193acc1cbe6fcb8dc51f9731f72e9ffffeb864c10f4167c1cd84
+  data.tar.gz: eff3b5a43e2efaed07990b15be1dfb42547bfbdc16cd980f6589f193cc91b258
+SHA512:
+  metadata.gz: 7e2a4ccef86a0fbea08fc8c2ab5a143e350225df42d6d1a8ca56e1d97723429c8294fc2c1802c5dbde2b683e7c5f09e88989f829e0ef73a8c23b03e6d0a2083d
+  data.tar.gz: 58aca74385f3e52b34d9252954481ddc388bcadd47b2203a58ca46033db0f851efba59fc6fb11193f3e9ad7726d6cbe2155b0f328e31c7b1f105d41374566725

data/lib/rune/network/buffer.rb

@@ -0,0 +1,75 @@
+module RuneRb::Network
+
+  # A Buffer encapsulates raw data in a String instance. Depending on the mode, the buffer can be read from or written to.
+  class Buffer
+
+    # Constructs a new Buffer instance.
+    # @param capacity [Integer] the capacity of the buffer.
+    # @param mode [String] the mode of the buffer.
+    def initialize(mode: 'rw')
+      @data = String.new
+      @mode = mode
+      raise StandardError, 'Buffer mode must include "r" or "w".' unless @mode.include?('r') || @mode.include?('w')
+
+      enable_readable if @mode.include?('r')
+      enable_writeable if @mode.include?('w')
+    end
+
+    # Returns a snapshot of the buffer.
+    # @return [String] a snapshot of the buffer.
+    def snapshot
+      @data.dup
+    end
+
+    # Returns the limit of the buffer.
+    # @return [Integer] the limit of the buffer.
+    def length
+      @data.bytesize
+    end
+
+    # Adds raw data to the buffer. Flips the buffer if it is readable.
+    # @param data [String] the data to add.
+    def <<(data)
+      @data << data
+    end
+
+    # Is the <Buffer> instance readable?
+    # @return [Boolean] true if the <Buffer> instance is readable, false otherwise.
+    def readable?
+      @mode.include?('r')
+    end
+
+    # Is the <Buffer> instance writeable?
+    # @return [Boolean] true if the <Buffer> instance is writeable, false otherwise.
+    def writeable?
+      @mode.include?('w')
+    end
+
+    # Mutates the value according to the passed mutation
+    # @param value [Integer] the value to mutate
+    # @param mutation [Symbol] the mutation to apply to the value.
+    def mutate(value, mutation)
+      case mutation
+      when :STD then value
+      when :ADD then value + 128
+      when :NEG then -value
+      when :SUB then value - 128
+      else mutate(value, :STD)
+      end
+    end
+
+    private
+
+    # Enables read functions on the buffer instance. Bit Access is disabled by default. Sets the bit position to 0.
+    def enable_readable
+      singleton_class.include(RuneRb::Network::Readable)
+      @bit_access = false
+      @bit_position = 0
+    end
+
+    # Enables write functions on the buffer instance.
+    def enable_writeable
+      singleton_class.include(RuneRb::Network::Writeable)
+    end
+  end
+end

data/lib/rune/network/constants.rb

@@ -0,0 +1,21 @@
+module RuneRb::Network::Constants
+  # Acceptable byte orders in which multi-byte values can be read.
+  # @return [Array<Symbol>]
+  BYTE_ORDERS = %i[BIG MIDDLE INVERSE_MIDDLE LITTLE].freeze
+
+  # The size of one byte
+  # @return [Integer]
+  BYTE_SIZE = 8
+
+  # Valid byte mutations
+  # @return [Array<Symbol>]
+  BYTE_MUTATIONS = %i[ADD NEG SUB STD].freeze
+
+  # Valid types for reading/writing
+  # @return [Array<Symbol>]
+  RW_TYPES = %i[bits bit byte bytes medium int long reverse_bytes short smart string].freeze
+
+  # Bit masks for bit packing
+  # @return [Array<Integer>]
+  BIT_MASK_OUT = (0...32).collect { (1 << _1) - 1 }.freeze
+end

data/lib/rune/network/isaac.rb

@@ -0,0 +1,219 @@
+module RuneRb::Network
+  # An implementation of an ISAAC cipher used to generate random numbers for message interchange.
+  class ISAAC
+    using RuneRb::Patches::IntegerRefinements
+
+    # Called when a new ISAAC Cipher is created.
+    def initialize(seed)
+      @aa = 0
+      @bb = 0
+      @cc = 0
+      @mm = []
+      @randrsl = Array.new(256, 0)
+
+      seed.each_with_index do |element, i|
+        @randrsl[i] = element
+      end
+
+      randinit
+    end
+
+    # Gets the next random value.
+    # If 256 cycles have occurred, the results array is regenerated.
+    def next_value
+      if @randcnt.zero?
+        isaac
+        @randcnt = 256
+      end
+      @randcnt -= 1
+      @randrsl[@randcnt].signed(:i)
+    end
+
+    private
+
+    # Generates 256 new results.
+    def isaac
+      r = @randrsl
+      aa = @aa
+      @cc += 1
+      bb = (@bb + (@cc)) & 0xffffffff
+      x = y = 0
+
+      (0...256).step(4) do |i|
+        x = @mm[i]
+        aa = ((aa ^ (aa << 13)) + @mm[(i + 128) & 0xff])
+        aa &= 0xffffffff
+        @mm[i] = y = (@mm[(x >> 2) & 0xff] + aa + bb) & 0xffffffff
+        r[i] = bb = (@mm[(y >> 10) & 0xff] + x) & 0xffffffff
+        x = @mm[i + 1]
+        aa = ((aa ^ (0x03ffffff & (aa >> 6))) + @mm[(i + 1 + 128) & 0xff])
+        aa &= 0xffffffff
+        @mm[i + 1] = y = (@mm[(x >> 2) & 0xff] + aa + bb) & 0xffffffff
+        r[i + 1] = bb = (@mm[(y >> 10) & 0xff] + x) & 0xffffffff
+        x = @mm[i + 2]
+        aa = ((aa ^ (aa << 2)) + @mm[(i + 2 + 128) & 0xff])
+        aa &= 0xffffffff
+        @mm[i + 2] = y = (@mm[(x >> 2) & 0xff] + aa + bb) & 0xffffffff
+        r[i + 2] = bb = (@mm[(y >> 10) & 0xff] + x) & 0xffffffff
+        x = @mm[i + 3]
+        aa = ((aa ^ (0x0000ffff & (aa >> 16))) + @mm[(i + 3 + 128) & 0xff])
+        aa &= 0xffffffff
+        @mm[i + 3] = y = (@mm[(x >> 2) & 0xff] + aa + bb) & 0xffffffff
+        r[i + 3] = bb = (@mm[(y >> 10) & 0xff] + x) & 0xffffffff
+      end
+
+      @bb = bb
+      @aa = aa
+    end
+
+    # Initializes the memory array.
+    def randinit
+      c = d = e = f = g = h = j = k = 0x9e3779b9
+      r = @randrsl
+
+      4.times do
+        c = c ^ (d << 11)
+        f += c
+        d += e
+        d = d ^ (0x3fffffff & (e >> 2))
+        g += d
+        e += f
+        e = e ^ (f << 8)
+        h += e
+        f += g
+        f = f ^ (0x0000ffff & (g >> 16))
+        j += f
+        g += h
+        g = g ^ (h << 10)
+        k += g
+        h += j
+        h = h ^ (0x0fffffff & (j >> 4))
+        c += h
+        j += k
+        j = j ^ (k << 8)
+        d += j
+        k += c
+        k = k ^ (0x007fffff & (c >> 9))
+        e += k
+        c += d
+      end
+
+      (0...256).step(8) do |i|
+        c += r[i]
+        d += r[i + 1]
+        e += r[i + 2]
+        f += r[i + 3]
+        g += r[i + 4]
+        h += r[i + 5]
+        j += r[i + 6]
+        k += r[i + 7]
+        c = c ^ (d << 11)
+        f += c
+        d += e
+        d = d ^ (0x3fffffff & (e >> 2))
+        g += d
+        e += f
+        e = e ^ (f << 8)
+        h += e
+        f += g
+        f = f ^ (0x0000ffff & (g >> 16))
+        j += f
+        g += h
+        g = g ^ (h << 10)
+        k += g
+        h += j
+        h = h ^ (0x0fffffff & (j >> 4))
+        c += h
+        j += k
+        j = j ^ (k << 8)
+        d += j
+        k += c
+        k = k ^ (0x007fffff & (c >> 9))
+        e += k
+        c += d
+        @mm[i] = c
+        @mm[i + 1] = d
+        @mm[i + 2] = e
+        @mm[i + 3] = f
+        @mm[i + 4] = g
+        @mm[i + 5] = h
+        @mm[i + 6] = j
+        @mm[i + 7] = k
+      end
+
+      (0...256).step(8) do |i|
+        c += @mm[i]
+        d += @mm[i + 1]
+        e += @mm[i + 2]
+        f += @mm[i + 3]
+        g += @mm[i + 4]
+        h += @mm[i + 5]
+        j += @mm[i + 6]
+        k += @mm[i + 7]
+        c = c ^ (d << 11)
+        f += c
+        d += e
+        d = d ^ (0x3fffffff & (e >> 2))
+        g += d
+        e += f
+        e = e ^ (f << 8)
+        h += e
+        f += g
+        f = f ^ (0x0000ffff & (g >> 16))
+        j += f
+        g += h
+        g = g ^ (h << 10)
+        k += g
+        h += j
+        h = h ^ (0x0fffffff & (j >> 4))
+        c += h
+        j += k
+        j = j ^ (k << 8)
+        d += j
+        k += c
+        k = k ^ (0x007fffff & (c >> 9))
+        e += k
+        c += d
+        @mm[i] = c
+        @mm[i + 1] = d
+        @mm[i + 2] = e
+        @mm[i + 3] = f
+        @mm[i + 4] = g
+        @mm[i + 5] = h
+        @mm[i + 6] = j
+        @mm[i + 7] = k
+      end
+
+      isaac
+      @randcnt = 256
+    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/lib/rune/network/readable.rb

@@ -0,0 +1,220 @@
+# The Readable module contains the functions used to read data from a {Buffer} object.
+module RuneRb::Network::Readable
+  using RuneRb::Patches::IntegerRefinements
+
+  # @!attribute [r] bit_access
+  # @return [Boolean] is {bit_access} enabled?
+  attr_reader :bit_access
+
+  # @!attribute [r] bit_position
+  # @return [Integer] the current bit position.
+  attr_reader :bit_position
+
+
+  # Read data from the payload according to the option parameter.
+  # @param type [Symbol] the type of database to read
+  # @param mutation [Symbol] an option mutation to apply to the read value.
+  def read(type: :byte, signed: false, mutation: :STD, order: :BIG, options: nil)
+    case type
+    when :bits then read_bits(options[:amount])
+    when :byte then read_byte(signed:, mutation:)
+    when :bytes then read_bytes(options[:amount] || 1, mutation:)
+    when :short then read_short(signed:, mutation:, order:)
+    when :int24 then read_int24(signed:, mutation:, order:)
+    when :int then read_int(signed:, mutation:, order:)
+    when :long then read_long(signed:, mutation:, order:)
+    when :smart then read_smart(signed:, mutation:)
+    when :string then read_string
+    when :reverse_bytes then read_bytes_reverse(options[:amount] || 1, mutation:)
+    else raise "Unrecognized read type! #{type}"
+    end
+  end
+
+  # Enables or Disables bit reading by setting the {Buffer#bit_access} variable.
+  def switch_access
+    @bit_access = !@bit_access
+  end
+
+  # Completes a bit access by setting the {Buffer#bit_position} to the start of the next byte, then toggling {bit_access}.
+  def finish_access
+    @bit_position = (@bit_position + 7) / 8
+    switch_access
+  end
+
+  private
+
+  # Read multiple bytes from the {Buffer#data}
+  # @param amount [Integer] the amount of bytes to read
+  # @param mutation [Symbol] the mutation to apply to read bytes.
+  def read_bytes(amount, mutation)
+    amount.times.each_with_object([]) { |_idx, arr| arr << read_byte(signed: false, mutation:) }
+  end
+
+  # Probably did this wrong
+  # @param amount [Integer] the amount of bytes to read
+  # @param mutation [Symbol] an optional mutation to apply to the result.
+  def read_bytes_reverse(amount, mutation)
+    @data.flip
+    value = amount.times.each_with_object([]) { value << read_byte(signed: false, mutation:) }
+    @data.flip
+    value
+  end
+
+  # Read a byte value from the {Buffer#data}
+  # @param signed [Boolean] should the value be signed.
+  # @param mutation [Symbol] mutation that should be applied to the byte value.
+  # @return [Integer] the read byte value.
+  def read_byte(mutation: :STD, signed: false)
+    directive = signed ? 'c' : 'C'
+    value = @data.slice!(0).unpack1(directive)
+    mutate(value, mutation)
+  end
+
+  # Reads a short value from the {Buffer#data}
+  # @param signed [Boolean] should the value be signed.
+  # @param mutation [String] mutation that should be applied to the short value
+  # @param order [Symbol] they byte order to read the short value
+  def read_short(signed: false, mutation: :STD, order: :BIG)
+    directive = "#{signed ? 's' : 'S'}"
+    directive << case order
+                 when :BIG then '>'
+                 when :LITTLE then '<'
+                 else ''
+                 end
+    value = @data.slice!(0..1).unpack1(directive)
+    mutate(value, mutation)
+  end
+
+  # Reads a 24-Bit Integer value from the {Buffer#data}
+  # @param signed [Boolean] should the value be signed.
+  # @param mutation [Symbol] mutation that should be applied to the value
+  # @param order [String] they byte order to read the value
+  def read_int24(signed: false, mutation: :STD, order: :BIG)
+    unpacked = @data.slice!(0..2).unpack('C3')
+    case order
+    when :BIG
+      if signed
+        value = (unpacked[0] << 16) | (unpacked[1] << 8) | unpacked[2]
+        unpacked[0] & 0x80 != 0 ? value - 0x10000 : value
+      else
+        (unpacked[0] << 16) | (unpacked[1] << 8) | unpacked[2]
+      end
+    when :MIDDLE
+      if signed
+        value = (unpacked[1] << 16) | (unpacked[2] << 8) | unpacked[0]
+        unpacked[1] & 0x80 != 0 ? value - 0x10000 : value
+      else
+        (unpacked[1] << 16) | (unpacked[2] << 8) | unpacked[0]
+      end
+    when :LITTLE
+      if signed
+        value = (unpacked[2] << 16) | (unpacked[1] << 8) | unpacked[0]
+        unpacked[0] & 0x80 != 0 ? value - 0x10000 : value
+      else
+        (unpacked[2] << 16) | (unpacked[1] << 8) | unpacked[0]
+      end
+    else read_int24(signed:, mutation:, order: :BIG)
+    end
+  end
+
+  # Reads a integer value from the {Buffer#data}
+  # @param signed [Boolean] should the value be signed.
+  # @param mutation [Symbol] mutation that should be applied to the integer value
+  # @param order [String] they byte order to read the integer value
+  def read_int(signed: false, mutation: :STD, order: :BIG)
+    case order
+    when :BIG
+      directive = signed ? 'l>' : 'L>'
+      value = @data.slice!(0..3).unpack1(directive)
+      mutate(value, mutation)
+    when :MIDDLE
+      (read_byte(signed:) << 8) | read_byte(signed:, mutation:) | (read_byte(signed:) << 24) | (read_byte(signed:) << 16)
+    when :INVERSE_MIDDLE
+      (read_byte(signed:) << 16) | (read_byte(signed:) << 24) | read_byte(signed:, mutation:) | (read_byte(signed:) << 8)
+    when :LITTLE
+      directive = signed ? 'l<' : 'L<'
+      value = @data.slice!(0..3).unpack1(directive)
+      mutate(value, mutation)
+    else read_int(signed:, mutation:, order: :BIG)
+    end
+  end
+
+  # Reads a long value from the {Buffer#data}
+  # @param signed [Boolean] should the value be signed.
+  # @param mutation [Symbol] mutation that should be applied to the long value
+  # @param order [String] they byte order to read the long value
+  def read_long(signed: false, mutation: :STD, order: :BIG)
+    case order
+    when :BIG
+      directive = signed ? 'q>' : 'Q>'
+      value = @data.slice!(0..7).unpack1(directive)
+      mutate(value, mutation)
+    when :LITTLE
+      directive = signed ? 'q<' : 'Q<'
+      value = @data.slice!(0..7).unpack1(directive)
+      mutate(value, mutation)
+    else read_long(signed:, mutation:, order: :BIG)
+    end
+  end
+
+  # Read a smart value from the {Buffer#data}
+  # @param signed [Boolean] should the value be signed.
+  # @param mutation [Symbol] mutation that should be applied to the long value
+  def read_smart(signed: false, mutation: :STD)
+    peek = read_byte(signed:, mutation:)
+
+    if signed
+      if peek < 128
+        read_byte(signed:, mutation:) - 64
+      else
+        read_short(signed:, mutation:, order: :BIG) - 49_152
+      end
+    else
+      if peek < 128
+        read_byte(mutation:, signed:)
+      else
+        read_short(mutation:, signed:, order: :BIG) - 32_768
+      end
+    end
+  end
+
+  # Reads a string from the {Buffer#data}
+  # @return [String] the resulting string.
+  def read_string
+    val = ''
+    while (res = @data.slice!(0))
+      break if res == "\n"
+
+      val << res
+    end
+    val
+  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/lib/rune/network/writeable.rb

@@ -0,0 +1,224 @@
+# The Writeable module contains functions for writing data to a {Buffer} object.
+module RuneRb::Network::Writeable
+
+  # Write data to the payload.
+  # @param value [Integer, String, Message, Array] the value to write.
+  # @param type [Symbol] the type of value to write.
+  # @param mutation [Symbol] an option mutation to apply to the value.
+  # @param order [Symbol] the byte order to write the value.
+  def write(value, type: :byte, mutation: :STD, signed: false, order: :BIG, options: {})
+    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 :int24 then write_int24(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: signed)
+    when :string then write_string(value)
+    when :reverse_bytes then write_reverse_bytes(value)
+    else raise "Unrecognized write type! #{type}"
+    end
+  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, signed: false)
+    @data << [mutate(value, mutation)].pack(signed ? 'c' : '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, signed: false, order: :BIG)
+    case order
+    when :BIG
+      write_byte(value >> 8)
+      write_byte(value, mutation: mutation, signed: signed)
+    when :LITTLE
+      write_byte(value, mutation: mutation, signed: signed)
+      write_byte(value >> 8)
+    else raise "Unrecognized bit order: #{order}"
+    end
+  end
+
+  # Write a int24 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_int24(value, mutation: :STD, signed: false, order: :BIG)
+    case order
+    when :BIG
+      write_byte(value >> 16)
+      write_byte(value >> 8)
+      write_byte(value, mutation: mutation, signed: signed)
+    when :MIDDLE
+      write_byte(value >> 8)
+      write_byte(value, mutation: mutation, signed: signed)
+      write_byte(value >> 16)
+    when :LITTLE
+      write_byte(value, mutation: mutation, signed: signed)
+      write_byte(value >> 8)
+      write_byte(value >> 16)
+    else raise "Unrecognized byte 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, signed: false, order: :BIG)
+    case order
+    when :BIG
+      write_byte(value >> 24)
+      write_byte(value >> 16)
+      write_byte(value >> 8)
+      write_byte(value, mutation: mutation, signed: signed)
+    when :MIDDLE
+      write_byte(value >> 8)
+      write_byte(value, mutation: mutation, signed: signed)
+      write_byte(value >> 24)
+      write_byte(value >> 16)
+    when :INVERSE_MIDDLE
+      write_byte(value >> 16)
+      write_byte(value >> 24)
+      write_byte(value, mutation: mutation, signed: signed)
+      write_byte(value >> 8)
+    when :LITTLE
+      write_byte(value, mutation: mutation, signed: signed)
+      write_byte(value >> 8)
+      write_byte(value >> 16)
+      write_byte(value >> 24)
+    else raise "Unrecognized byte 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, signed: false, order: :BIG)
+    case order
+    when :BIG
+      (RuneRb::Network::BYTE_SIZE * 7).downto(0) { |div| ((div % 8).zero? and div.positive?) ? write_byte(value >> div) : next }
+      write_byte(value, mutation: mutation, signed: signed)
+    when :LITTLE
+      write_byte(value, mutation: mutation, signed: signed)
+      (0).upto(RuneRb::Network::BYTE_SIZE * 7) { |div| ((div % 8).zero? and div.positive?) ? write_byte(value >> div) : next }
+    else raise "Unrecognized byte order: #{order}"
+    end
+  end
+
+  # Write a string value to the payload. This will be escaped/terminated with a \n[10] value.
+  # @param string [String, StringIO] the byte to write to the payload.
+  def write_string(string)
+    send(:<<, string)
+    send(:<<, [10].pack('C'))
+  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 + 64, mutation: mutation, signed: signed)  : write_short(value + 49_152, mutation: mutation, signed: signed)
+    when false
+      value > 128 ? write_byte(value, mutation: mutation, signed: signed) : write_short(value + 32_768, mutation: mutation, signed: signed)
+    end
+  end
+
+  # Writes multiple bytes to the payload.
+  # @param values [String, Array, Rune::Network::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::Network::Packet then send(:put, values.snapshot)
+    when RuneRb::Network::Buffer then send(:put, values)
+    when String then send(:<<, 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
+      @buffer[byte_pos] = [0].pack('c') if @buffer[byte_pos].nil?
+      @buffer[byte_pos] = [(@buffer[byte_pos].unpack1('c') & ~RuneRb::Network::BIT_MASK_OUT[bit_offset])].pack('c')
+      @buffer[byte_pos] = [(@buffer[byte_pos].unpack1('c') | (value >> (amount - bit_offset)) & RuneRb::Network::BIT_MASK_OUT[bit_offset])].pack('c')
+      byte_pos += 1
+      amount -= bit_offset
+      bit_offset = 8
+    end
+
+    @buffer[byte_pos] = [0].pack('c') if @buffer[byte_pos].nil?
+
+    if amount == bit_offset
+      @buffer[byte_pos] = [(@buffer[byte_pos].unpack1('c') & ~RuneRb::Network::BIT_MASK_OUT[bit_offset])].pack('c')
+      @buffer[byte_pos] = [(@buffer[byte_pos].unpack1('c') | (value & Rune::Network::BIT_MASK_OUT[bit_offset]))].pack('c')
+    else
+      @buffer[byte_pos] = [(@buffer[byte_pos].unpack1('c') & ~(RuneRb::Network::BIT_MASK_OUT[amount] << (bit_offset - amount)))].pack('c')
+      @buffer[byte_pos] = [(@buffer[byte_pos].unpack1('c') | ((value & RuneRb::Network::BIT_MASK_OUT[amount]) << (bit_offset - amount)))].pack('c')
+    end
+  end
+end
+
+############################################################################################################
+#  Copyright (c) 2023, 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/rune/patches/integer_refinements.rb

@@ -0,0 +1,123 @@
+# A module adding overflow functions to integers to mimic the behavior of Java primitive overflow behavior.
+module RuneRb::Patches::IntegerRefinements
+  refine Integer do
+    # Returns a binary representation in the form of an array of 1's and 0's in their respective digits.
+    # @return [Array] the binary representation
+    def binary_representation
+      to_s(2).chars.map(&:to_i)
+    end
+
+    alias_method :brep, :binary_representation
+
+    # Returns a base 10 numeric from the passed array representation
+    # @param representation [Array] the representation used to generate the numeric
+    # @returns [Integer] the base 10 numeric of the representation.
+    def from_binary_rep(representation)
+      res = 0
+      representation.each_with_index do |bit, idx|
+        res += bit * (2**idx)
+      end
+      res
+    end
+
+    alias_method :from_brep, :from_binary_rep
+
+    # Adjusts the value of the Integer to be unsigned.
+    # @param type [Symbol] the type of primitive the value will be returned as
+    def unsigned(type)
+      return 0 if negative?
+      case type
+      when :Byte, :byte, :b, :B then to_i > 0xFF ? 0xFF : to_i
+      when :Short, :short, :s, :S then to_i > 0xFFFF ? 0xFFFF : to_i
+      when :Integer, :Int, :int, :integer, :i, :I then to_i > 0xFFFFFFFF ? 0xFFFFFFFF : to_i
+      when :Long, :long, :l, :L then to_i > 0xFFFFFFFFFFFFFFFF ? 0xFFFFFFFFFFFFFFFF : to_i
+      else unsigned(:int)
+      end
+    end
+
+    alias_method :u, :unsigned
+
+    # Adjusts the value of the Integer to be signed.
+    # @param type [Symbol] the type of primitive the value will be returned as
+    def signed(type)
+      case type
+      when :Byte, :byte, :b, :B then adjust(:byte)
+      when :Short, :short, :s, :S then adjust(:short)
+      when :Integer, :Int, :int, :integer, :i, :I then adjust(:integer)
+      when :Long, :long, :l, :L then adjust(:long)
+      else adjust(:integer)
+      end
+    end
+
+    alias_method :s, :signed
+
+    def nibble
+      adjust(:nibble)
+    end
+
+    # Returns a string with a formatted representation of the Integer as a timestamp.
+    def to_ftime
+      mm, ss = divmod(60)
+      hh, mm = mm.divmod(60)
+      dd, hh = hh.divmod(24)
+      format('%d days, %d hours, %d minutes, and %d seconds', dd, hh, mm, ss)
+    end
+
+    private
+
+    # Adjusts the integer based on the passed type
+    # @param type [Symbol] the type of adjustment to make to the integer.
+    def adjust(type)
+      case type
+      when :Byte, :byte, :b, :B
+        primitive_max = 2**7 - 1
+        primitive_min = -2**7
+      when :Short, :short, :s, :S
+        primitive_max = 2**15 - 1
+        primitive_min = -2**15
+      when :Integer, :Int, :int, :i, :I
+        primitive_max = 2**31 - 1
+        primitive_min = -2**31
+      when :Long, :long, :l, :L
+        primitive_max = 2**63 - 1
+        primitive_min = -2**63
+      when :Nibble, :nibble, :n, :N
+        primitive_max = 2**4
+        primitive_min = -2**4
+      else
+        primitive_max = 2**31 - 1
+        primitive_min = -2**31
+      end
+      self < -primitive_max ? -1 * (-self & primitive_max) : self
+      self > primitive_min ? (self & primitive_max) : self
+    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/lib/rune/patches/set_refinements.rb

@@ -0,0 +1,43 @@
+# Refinements made to the Set class of the ruby Core module.
+module RuneRb::Patches::SetRefinements
+  refine Set do
+    # Consumes elements as they're passed to execution block.
+    # @param _ [Proc] the execution block
+    def each_consume(&_)
+      raise 'Nil block passed to Set#each_consume.' unless block_given?
+
+      each do |item|
+        yield(item)
+        delete(item)
+      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/lib/rune.rb

@@ -0,0 +1,29 @@
+Dir[File.dirname(__FILE__)].each { |file| $LOAD_PATH.unshift(file) if File.directory? file }
+
+require 'nio/bytebuffer'
+
+# <h1>RuneRb</h1>
+# <p>A game server written in Ruby targeting the 2006 era (or the 317-377 protocols) of the popular MMORPG, RuneScape.</p>
+#
+#
+# @author Patrick W.
+# @since 0.0.1
+module RuneRb
+
+  # The Network module contains all common network related classes and modules.
+  module Network
+    autoload :Buffer,             'rune/network/buffer'
+    autoload :Constants,          'rune/network/constants'
+    autoload :ISAAC,              'rune/network/isaac'
+    autoload :Readable,           'rune/network/readable'
+    autoload :Writeable,          'rune/network/writeable'
+
+    include Constants
+  end
+
+  # The Patches module contains all common patches to core classes.
+  module Patches
+    autoload :IntegerRefinements, 'rune/patches/integer_refinements'
+    autoload :SetRefinements,     'rune/patches/set_refinements'
+  end
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: rrb-common
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Patrick W.
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-11-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nio4r
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.5.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.5.9
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: benchmark
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.19'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.19'
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A set of common classes, modules, and functions for Rune.rb.
+email: Sickday@pm.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rune.rb
+- lib/rune/network/buffer.rb
+- lib/rune/network/constants.rb
+- lib/rune/network/isaac.rb
+- lib/rune/network/readable.rb
+- lib/rune/network/writeable.rb
+- lib/rune/patches/integer_refinements.rb
+- lib/rune/patches/set_refinements.rb
+homepage:
+licenses:
+- BSD-3-Clause
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Common utilities for RuneRb.
+test_files: []