sc2ai 0.4.2 → 0.5.0

data/lib/sc2ai/protocol/debug_pb.rb

@@ -19,63 +19,35 @@ module Api
     FAST_BUILD = 12
 
     def self.lookup(val)
-      if val == 0
-        :ENUM_DEBUG_GAME_STATE_UNSET
-      elsif val == 1
-        :SHOW_MAP
-      elsif val == 2
-        :CONTROL_ENEMY
-      elsif val == 3
-        :FOOD
-      elsif val == 4
-        :FREE
-      elsif val == 5
-        :ALL_RESOURCES
-      elsif val == 6
-        :GOD
-      elsif val == 7
-        :MINERALS
-      elsif val == 8
-        :GAS
-      elsif val == 9
-        :COOLDOWNS
-      elsif val == 10
-        :TECH_TREE
-      elsif val == 11
-        :UPGRADE
-      elsif val == 12
-        :FAST_BUILD
-      end
+      return :ENUM_DEBUG_GAME_STATE_UNSET if val == 0
+      return :SHOW_MAP if val == 1
+      return :CONTROL_ENEMY if val == 2
+      return :FOOD if val == 3
+      return :FREE if val == 4
+      return :ALL_RESOURCES if val == 5
+      return :GOD if val == 6
+      return :MINERALS if val == 7
+      return :GAS if val == 8
+      return :COOLDOWNS if val == 9
+      return :TECH_TREE if val == 10
+      return :UPGRADE if val == 11
+      return :FAST_BUILD if val == 12
     end
 
     def self.resolve(val)
-      if val == :ENUM_DEBUG_GAME_STATE_UNSET
-        0
-      elsif val == :SHOW_MAP
-        1
-      elsif val == :CONTROL_ENEMY
-        2
-      elsif val == :FOOD
-        3
-      elsif val == :FREE
-        4
-      elsif val == :ALL_RESOURCES
-        5
-      elsif val == :GOD
-        6
-      elsif val == :MINERALS
-        7
-      elsif val == :GAS
-        8
-      elsif val == :COOLDOWNS
-        9
-      elsif val == :TECH_TREE
-        10
-      elsif val == :UPGRADE
-        11
-      elsif val == :FAST_BUILD
-        12
-      end
+      return 0 if val == :ENUM_DEBUG_GAME_STATE_UNSET
+      return 1 if val == :SHOW_MAP
+      return 2 if val == :CONTROL_ENEMY
+      return 3 if val == :FOOD
+      return 4 if val == :FREE
+      return 5 if val == :ALL_RESOURCES
+      return 6 if val == :GOD
+      return 7 if val == :MINERALS
+      return 8 if val == :GAS
+      return 9 if val == :COOLDOWNS
+      return 10 if val == :TECH_TREE
+      return 11 if val == :UPGRADE
+      return 12 if val == :FAST_BUILD
     end
   end
 
@@ -293,20 +265,39 @@ module Api
         # unexpected, so discard it and continue.
         if !found
           wire_type = tag & 0x7
+
+          unknown_bytes = +"".b
+          val = tag
+          loop do
+            byte = val & 0x7F
+
+            val >>= 7
+            # This drops the top bits,
+            # Otherwise, with a signed right shift,
+            # we get infinity one bits at the top
+            val &= (1 << 57) - 1
+
+            byte |= 0x80 if val != 0
+            unknown_bytes << byte
+            break if val == 0
+          end
+
           case wire_type
           when 0
             i = 0
             while true
               newbyte = buff.getbyte(index)
               index += 1
-              break if newbyte.nil? || newbyte < 0x80
+              break if newbyte.nil?
+              unknown_bytes << newbyte
+              break if newbyte < 0x80
               i += 1
               break if i > 9
             end
           when 1
+            unknown_bytes << buff.byteslice(index, 8)
             index += 8
           when 2
-            ## PULL_BYTES
             value =
               if (byte0 = buff.getbyte(index)) < 0x80
                 index += 1
@@ -362,15 +353,30 @@ module Api
                 raise "integer decoding error"
               end
 
-            buff.byteslice(index, value)
-            index += value
+            val = value
+            loop do
+              byte = val & 0x7F
+
+              val >>= 7
+              # This drops the top bits,
+              # Otherwise, with a signed right shift,
+              # we get infinity one bits at the top
+              val &= (1 << 57) - 1
+
+              byte |= 0x80 if val != 0
+              unknown_bytes << byte
+              break if val == 0
+            end
 
-            ## END PULL_BYTES
+            unknown_bytes << buff.byteslice(index, value)
+            index += value
           when 5
+            unknown_bytes << buff.byteslice(index, 4)
             index += 4
           else
             raise "unknown wire type #{wire_type}"
           end
+          (@_unknown_fields ||= +"".b) << unknown_bytes
           return self if index >= len
           ## PULL_UINT64
           tag =
@@ -1418,7 +1424,7 @@ module Api
       if val != 0
         buff << 0x10
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -1429,6 +1435,7 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
@@ -1719,15 +1726,93 @@ module Api
 
         buff
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      send("command").tap { |f| result[f.to_sym] = send(f) if f }
+
+      resolved_command = self.command
+
+      result[:"draw"] = @draw.to_h if resolved_command == :"draw"
+      result[:"game_state"] = @game_state if resolved_command == :"game_state"
+      result[:"create_unit"] = @create_unit.to_h if resolved_command ==
+        :"create_unit"
+      result[:"kill_unit"] = @kill_unit.to_h if resolved_command == :"kill_unit"
+      result[:"test_process"] = @test_process.to_h if resolved_command ==
+        :"test_process"
+      result[:"score"] = @score.to_h if resolved_command == :"score"
+      result[:"end_game"] = @end_game.to_h if resolved_command == :"end_game"
+      result[:"unit_value"] = @unit_value.to_h if resolved_command ==
+        :"unit_value"
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      resolved_command = self.command
+
+      result["draw"] = (
+        if @draw.nil?
+          {}
+        else
+          @draw.as_json(options)
+        end
+      ) if resolved_command == :"draw"
+      result["gameState"] = @game_state if resolved_command == :"game_state"
+      result["createUnit"] = (
+        if @create_unit.nil?
+          {}
+        else
+          @create_unit.as_json(options)
+        end
+      ) if resolved_command == :"create_unit"
+      result["killUnit"] = (
+        if @kill_unit.nil?
+          {}
+        else
+          @kill_unit.as_json(options)
+        end
+      ) if resolved_command == :"kill_unit"
+      result["testProcess"] = (
+        if @test_process.nil?
+          {}
+        else
+          @test_process.as_json(options)
+        end
+      ) if resolved_command == :"test_process"
+      result["score"] = (
+        if @score.nil?
+          {}
+        else
+          @score.as_json(options)
+        end
+      ) if resolved_command == :"score"
+      result["endGame"] = (
+        if @end_game.nil?
+          {}
+        else
+          @end_game.as_json(options)
+        end
+      ) if resolved_command == :"end_game"
+      result["unitValue"] = (
+        if @unit_value.nil?
+          {}
+        else
+          @unit_value.as_json(options)
+        end
+      ) if resolved_command == :"unit_value"
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class DebugDraw
     def self.decode(buff)
@@ -1842,20 +1927,39 @@ module Api
         # unexpected, so discard it and continue.
         if !found
           wire_type = tag & 0x7
+
+          unknown_bytes = +"".b
+          val = tag
+          loop do
+            byte = val & 0x7F
+
+            val >>= 7
+            # This drops the top bits,
+            # Otherwise, with a signed right shift,
+            # we get infinity one bits at the top
+            val &= (1 << 57) - 1
+
+            byte |= 0x80 if val != 0
+            unknown_bytes << byte
+            break if val == 0
+          end
+
           case wire_type
           when 0
             i = 0
             while true
               newbyte = buff.getbyte(index)
               index += 1
-              break if newbyte.nil? || newbyte < 0x80
+              break if newbyte.nil?
+              unknown_bytes << newbyte
+              break if newbyte < 0x80
               i += 1
               break if i > 9
             end
           when 1
+            unknown_bytes << buff.byteslice(index, 8)
             index += 8
           when 2
-            ## PULL_BYTES
             value =
               if (byte0 = buff.getbyte(index)) < 0x80
                 index += 1
@@ -1911,15 +2015,30 @@ module Api
                 raise "integer decoding error"
               end
 
-            buff.byteslice(index, value)
-            index += value
+            val = value
+            loop do
+              byte = val & 0x7F
+
+              val >>= 7
+              # This drops the top bits,
+              # Otherwise, with a signed right shift,
+              # we get infinity one bits at the top
+              val &= (1 << 57) - 1
+
+              byte |= 0x80 if val != 0
+              unknown_bytes << byte
+              break if val == 0
+            end
 
-            ## END PULL_BYTES
+            unknown_bytes << buff.byteslice(index, value)
+            index += value
           when 5
+            unknown_bytes << buff.byteslice(index, 4)
             index += 4
           else
             raise "unknown wire type #{wire_type}"
           end
+          (@_unknown_fields ||= +"".b) << unknown_bytes
           return self if index >= len
           ## PULL_UINT64
           tag =
@@ -2735,18 +2854,47 @@ module Api
           end
         end
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      result["text".to_sym] = @text
-      result["lines".to_sym] = @lines
-      result["boxes".to_sym] = @boxes
-      result["spheres".to_sym] = @spheres
+
+      result[:"text"] = @text.map(&:to_h)
+      result[:"lines"] = @lines.map(&:to_h)
+      result[:"boxes"] = @boxes.map(&:to_h)
+      result[:"spheres"] = @spheres.map(&:to_h)
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      tmp_text = @text.map { |v| v.as_json(options) }
+
+      result["text"] = tmp_text if !options[:compact] || tmp_text.any?
+
+      tmp_lines = @lines.map { |v| v.as_json(options) }
+
+      result["lines"] = tmp_lines if !options[:compact] || tmp_lines.any?
+
+      tmp_boxes = @boxes.map { |v| v.as_json(options) }
+
+      result["boxes"] = tmp_boxes if !options[:compact] || tmp_boxes.any?
+
+      tmp_spheres = @spheres.map { |v| v.as_json(options) }
+
+      result["spheres"] = tmp_spheres if !options[:compact] || tmp_spheres.any?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class Line
     def self.decode(buff)
@@ -2872,20 +3020,39 @@ module Api
         # unexpected, so discard it and continue.
         if !found
           wire_type = tag & 0x7
+
+          unknown_bytes = +"".b
+          val = tag
+          loop do
+            byte = val & 0x7F
+
+            val >>= 7
+            # This drops the top bits,
+            # Otherwise, with a signed right shift,
+            # we get infinity one bits at the top
+            val &= (1 << 57) - 1
+
+            byte |= 0x80 if val != 0
+            unknown_bytes << byte
+            break if val == 0
+          end
+
           case wire_type
           when 0
             i = 0
             while true
               newbyte = buff.getbyte(index)
               index += 1
-              break if newbyte.nil? || newbyte < 0x80
+              break if newbyte.nil?
+              unknown_bytes << newbyte
+              break if newbyte < 0x80
               i += 1
               break if i > 9
             end
           when 1
+            unknown_bytes << buff.byteslice(index, 8)
             index += 8
           when 2
-            ## PULL_BYTES
             value =
               if (byte0 = buff.getbyte(index)) < 0x80
                 index += 1
@@ -2941,15 +3108,30 @@ module Api
                 raise "integer decoding error"
               end
 
-            buff.byteslice(index, value)
-            index += value
+            val = value
+            loop do
+              byte = val & 0x7F
 
-            ## END PULL_BYTES
+              val >>= 7
+              # This drops the top bits,
+              # Otherwise, with a signed right shift,
+              # we get infinity one bits at the top
+              val &= (1 << 57) - 1
+
+              byte |= 0x80 if val != 0
+              unknown_bytes << byte
+              break if val == 0
+            end
+
+            unknown_bytes << buff.byteslice(index, value)
+            index += value
           when 5
+            unknown_bytes << buff.byteslice(index, 4)
             index += 4
           else
             raise "unknown wire type #{wire_type}"
           end
+          (@_unknown_fields ||= +"".b) << unknown_bytes
           return self if index >= len
           ## PULL_UINT64
           tag =
@@ -3329,16 +3511,36 @@ module Api
 
         buff
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      result["p0".to_sym] = @p0.to_h
-      result["p1".to_sym] = @p1.to_h
+
+      result[:"p0"] = @p0.to_h
+      result[:"p1"] = @p1.to_h
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      result["p0"] = @p0.nil? ? {} : @p0.as_json(options) if !options[
+        :compact
+      ] || has_p0?
+      result["p1"] = @p1.nil? ? {} : @p1.as_json(options) if !options[
+        :compact
+      ] || has_p1?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class Color
     def self.decode(buff)
@@ -3510,20 +3712,39 @@ module Api
         # unexpected, so discard it and continue.
         if !found
           wire_type = tag & 0x7
+
+          unknown_bytes = +"".b
+          val = tag
+          loop do
+            byte = val & 0x7F
+
+            val >>= 7
+            # This drops the top bits,
+            # Otherwise, with a signed right shift,
+            # we get infinity one bits at the top
+            val &= (1 << 57) - 1
+
+            byte |= 0x80 if val != 0
+            unknown_bytes << byte
+            break if val == 0
+          end
+
           case wire_type
           when 0
             i = 0
             while true
               newbyte = buff.getbyte(index)
               index += 1
-              break if newbyte.nil? || newbyte < 0x80
+              break if newbyte.nil?
+              unknown_bytes << newbyte
+              break if newbyte < 0x80
               i += 1
               break if i > 9
             end
           when 1
+            unknown_bytes << buff.byteslice(index, 8)
             index += 8
           when 2
-            ## PULL_BYTES
             value =
               if (byte0 = buff.getbyte(index)) < 0x80
                 index += 1
@@ -3579,15 +3800,30 @@ module Api
                 raise "integer decoding error"
               end
 
-            buff.byteslice(index, value)
-            index += value
+            val = value
+            loop do
+              byte = val & 0x7F
+
+              val >>= 7
+              # This drops the top bits,
+              # Otherwise, with a signed right shift,
+              # we get infinity one bits at the top
+              val &= (1 << 57) - 1
+
+              byte |= 0x80 if val != 0
+              unknown_bytes << byte
+              break if val == 0
+            end
 
-            ## END PULL_BYTES
+            unknown_bytes << buff.byteslice(index, value)
+            index += value
           when 5
+            unknown_bytes << buff.byteslice(index, 4)
             index += 4
           else
             raise "unknown wire type #{wire_type}"
           end
+          (@_unknown_fields ||= +"".b) << unknown_bytes
           return self if index >= len
           ## PULL_UINT64
           tag =
@@ -3973,51 +4209,71 @@ module Api
     end
     def _encode(buff)
       val = @r
-      if val != 0
+      if has_r?
         buff << 0x08
 
-        while val != 0
+        loop do
           byte = val & 0x7F
           val >>= 7
           byte |= 0x80 if val > 0
           buff << byte
+          break if val == 0
         end
       end
 
       val = @g
-      if val != 0
+      if has_g?
         buff << 0x10
 
-        while val != 0
+        loop do
           byte = val & 0x7F
           val >>= 7
           byte |= 0x80 if val > 0
           buff << byte
+          break if val == 0
         end
       end
 
       val = @b
-      if val != 0
+      if has_b?
         buff << 0x18
 
-        while val != 0
+        loop do
           byte = val & 0x7F
           val >>= 7
           byte |= 0x80 if val > 0
           buff << byte
+          break if val == 0
         end
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      result["r".to_sym] = @r
-      result["g".to_sym] = @g
-      result["b".to_sym] = @b
+
+      result[:"r"] = @r
+      result[:"g"] = @g
+      result[:"b"] = @b
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      result["r"] = @r if !options[:compact] || has_r?
+      result["g"] = @g if !options[:compact] || has_g?
+      result["b"] = @b if !options[:compact] || has_b?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class DebugText
     def self.decode(buff)
@@ -4215,20 +4471,39 @@ module Api
         # unexpected, so discard it and continue.
         if !found
           wire_type = tag & 0x7
+
+          unknown_bytes = +"".b
+          val = tag
+          loop do
+            byte = val & 0x7F
+
+            val >>= 7
+            # This drops the top bits,
+            # Otherwise, with a signed right shift,
+            # we get infinity one bits at the top
+            val &= (1 << 57) - 1
+
+            byte |= 0x80 if val != 0
+            unknown_bytes << byte
+            break if val == 0
+          end
+
           case wire_type
           when 0
             i = 0
             while true
               newbyte = buff.getbyte(index)
               index += 1
-              break if newbyte.nil? || newbyte < 0x80
+              break if newbyte.nil?
+              unknown_bytes << newbyte
+              break if newbyte < 0x80
               i += 1
               break if i > 9
             end
           when 1
+            unknown_bytes << buff.byteslice(index, 8)
             index += 8
           when 2
-            ## PULL_BYTES
             value =
               if (byte0 = buff.getbyte(index)) < 0x80
                 index += 1
@@ -4284,15 +4559,30 @@ module Api
                 raise "integer decoding error"
               end
 
-            buff.byteslice(index, value)
-            index += value
+            val = value
+            loop do
+              byte = val & 0x7F
+
+              val >>= 7
+              # This drops the top bits,
+              # Otherwise, with a signed right shift,
+              # we get infinity one bits at the top
+              val &= (1 << 57) - 1
+
+              byte |= 0x80 if val != 0
+              unknown_bytes << byte
+              break if val == 0
+            end
 
-            ## END PULL_BYTES
+            unknown_bytes << buff.byteslice(index, value)
+            index += value
           when 5
+            unknown_bytes << buff.byteslice(index, 4)
             index += 4
           else
             raise "unknown wire type #{wire_type}"
           end
+          (@_unknown_fields ||= +"".b) << unknown_bytes
           return self if index >= len
           ## PULL_UINT64
           tag =
@@ -4960,13 +5250,14 @@ module Api
       end
 
       val = @text
-      if ((len = val.bytesize) > 0)
+      if (len = val.bytesize) > 0 || has_text?
         buff << 0x12
-        while len != 0
+        loop do
           byte = len & 0x7F
           len >>= 7
           byte |= 0x80 if len > 0
           buff << byte
+          break if len == 0
         end
 
         buff << (val.ascii_only? ? val : val.b)
@@ -5069,29 +5360,63 @@ module Api
       end
 
       val = @size
-      if val != 0
+      if has_size?
         buff << 0x28
 
-        while val != 0
+        loop do
           byte = val & 0x7F
           val >>= 7
           byte |= 0x80 if val > 0
           buff << byte
+          break if val == 0
         end
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      result["color".to_sym] = @color.to_h
-      result["text".to_sym] = @text
-      result["virtual_pos".to_sym] = @virtual_pos.to_h
-      result["world_pos".to_sym] = @world_pos.to_h
-      result["size".to_sym] = @size
+
+      result[:"color"] = @color.to_h
+      result[:"text"] = @text
+      result[:"virtual_pos"] = @virtual_pos.to_h
+      result[:"world_pos"] = @world_pos.to_h
+      result[:"size"] = @size
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      result["color"] = @color.nil? ? {} : @color.as_json(options) if !options[
+        :compact
+      ] || has_color?
+      result["text"] = @text if !options[:compact] || has_text?
+      result["virtualPos"] = (
+        if @virtual_pos.nil?
+          {}
+        else
+          @virtual_pos.as_json(options)
+        end
+      ) if !options[:compact] || has_virtual_pos?
+      result["worldPos"] = (
+        if @world_pos.nil?
+          {}
+        else
+          @world_pos.as_json(options)
+        end
+      ) if !options[:compact] || has_world_pos?
+      result["size"] = @size if !options[:compact] || has_size?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class DebugLine
     def self.decode(buff)
@@ -5217,20 +5542,39 @@ module Api
         # unexpected, so discard it and continue.
         if !found
           wire_type = tag & 0x7
+
+          unknown_bytes = +"".b
+          val = tag
+          loop do
+            byte = val & 0x7F
+
+            val >>= 7
+            # This drops the top bits,
+            # Otherwise, with a signed right shift,
+            # we get infinity one bits at the top
+            val &= (1 << 57) - 1
+
+            byte |= 0x80 if val != 0
+            unknown_bytes << byte
+            break if val == 0
+          end
+
           case wire_type
           when 0
             i = 0
             while true
               newbyte = buff.getbyte(index)
               index += 1
-              break if newbyte.nil? || newbyte < 0x80
+              break if newbyte.nil?
+              unknown_bytes << newbyte
+              break if newbyte < 0x80
               i += 1
               break if i > 9
             end
           when 1
+            unknown_bytes << buff.byteslice(index, 8)
             index += 8
           when 2
-            ## PULL_BYTES
             value =
               if (byte0 = buff.getbyte(index)) < 0x80
                 index += 1
@@ -5286,15 +5630,30 @@ module Api
                 raise "integer decoding error"
               end
 
-            buff.byteslice(index, value)
-            index += value
+            val = value
+            loop do
+              byte = val & 0x7F
+
+              val >>= 7
+              # This drops the top bits,
+              # Otherwise, with a signed right shift,
+              # we get infinity one bits at the top
+              val &= (1 << 57) - 1
+
+              byte |= 0x80 if val != 0
+              unknown_bytes << byte
+              break if val == 0
+            end
 
-            ## END PULL_BYTES
+            unknown_bytes << buff.byteslice(index, value)
+            index += value
           when 5
+            unknown_bytes << buff.byteslice(index, 4)
             index += 4
           else
             raise "unknown wire type #{wire_type}"
           end
+          (@_unknown_fields ||= +"".b) << unknown_bytes
           return self if index >= len
           ## PULL_UINT64
           tag =
@@ -5675,16 +6034,36 @@ module Api
 
         buff
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      result["color".to_sym] = @color.to_h
-      result["line".to_sym] = @line.to_h
+
+      result[:"color"] = @color.to_h
+      result[:"line"] = @line.to_h
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      result["color"] = @color.nil? ? {} : @color.as_json(options) if !options[
+        :compact
+      ] || has_color?
+      result["line"] = @line.nil? ? {} : @line.as_json(options) if !options[
+        :compact
+      ] || has_line?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class DebugBox
     def self.decode(buff)
@@ -5829,20 +6208,39 @@ module Api
         # unexpected, so discard it and continue.
         if !found
           wire_type = tag & 0x7
+
+          unknown_bytes = +"".b
+          val = tag
+          loop do
+            byte = val & 0x7F
+
+            val >>= 7
+            # This drops the top bits,
+            # Otherwise, with a signed right shift,
+            # we get infinity one bits at the top
+            val &= (1 << 57) - 1
+
+            byte |= 0x80 if val != 0
+            unknown_bytes << byte
+            break if val == 0
+          end
+
           case wire_type
           when 0
             i = 0
             while true
               newbyte = buff.getbyte(index)
               index += 1
-              break if newbyte.nil? || newbyte < 0x80
+              break if newbyte.nil?
+              unknown_bytes << newbyte
+              break if newbyte < 0x80
               i += 1
               break if i > 9
             end
           when 1
+            unknown_bytes << buff.byteslice(index, 8)
             index += 8
           when 2
-            ## PULL_BYTES
             value =
               if (byte0 = buff.getbyte(index)) < 0x80
                 index += 1
@@ -5898,15 +6296,30 @@ module Api
                 raise "integer decoding error"
               end
 
-            buff.byteslice(index, value)
-            index += value
+            val = value
+            loop do
+              byte = val & 0x7F
 
-            ## END PULL_BYTES
+              val >>= 7
+              # This drops the top bits,
+              # Otherwise, with a signed right shift,
+              # we get infinity one bits at the top
+              val &= (1 << 57) - 1
+
+              byte |= 0x80 if val != 0
+              unknown_bytes << byte
+              break if val == 0
+            end
+
+            unknown_bytes << buff.byteslice(index, value)
+            index += value
           when 5
+            unknown_bytes << buff.byteslice(index, 4)
             index += 4
           else
             raise "unknown wire type #{wire_type}"
           end
+          (@_unknown_fields ||= +"".b) << unknown_bytes
           return self if index >= len
           ## PULL_UINT64
           tag =
@@ -6447,17 +6860,40 @@ module Api
 
         buff
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      result["color".to_sym] = @color.to_h
-      result["min".to_sym] = @min.to_h
-      result["max".to_sym] = @max.to_h
+
+      result[:"color"] = @color.to_h
+      result[:"min"] = @min.to_h
+      result[:"max"] = @max.to_h
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      result["color"] = @color.nil? ? {} : @color.as_json(options) if !options[
+        :compact
+      ] || has_color?
+      result["min"] = @min.nil? ? {} : @min.as_json(options) if !options[
+        :compact
+      ] || has_min?
+      result["max"] = @max.nil? ? {} : @max.as_json(options) if !options[
+        :compact
+      ] || has_max?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class DebugSphere
     def self.decode(buff)
@@ -6602,20 +7038,39 @@ module Api
         # unexpected, so discard it and continue.
         if !found
           wire_type = tag & 0x7
+
+          unknown_bytes = +"".b
+          val = tag
+          loop do
+            byte = val & 0x7F
+
+            val >>= 7
+            # This drops the top bits,
+            # Otherwise, with a signed right shift,
+            # we get infinity one bits at the top
+            val &= (1 << 57) - 1
+
+            byte |= 0x80 if val != 0
+            unknown_bytes << byte
+            break if val == 0
+          end
+
           case wire_type
           when 0
             i = 0
             while true
               newbyte = buff.getbyte(index)
               index += 1
-              break if newbyte.nil? || newbyte < 0x80
+              break if newbyte.nil?
+              unknown_bytes << newbyte
+              break if newbyte < 0x80
               i += 1
               break if i > 9
             end
           when 1
+            unknown_bytes << buff.byteslice(index, 8)
             index += 8
           when 2
-            ## PULL_BYTES
             value =
               if (byte0 = buff.getbyte(index)) < 0x80
                 index += 1
@@ -6671,15 +7126,30 @@ module Api
                 raise "integer decoding error"
               end
 
-            buff.byteslice(index, value)
-            index += value
+            val = value
+            loop do
+              byte = val & 0x7F
+
+              val >>= 7
+              # This drops the top bits,
+              # Otherwise, with a signed right shift,
+              # we get infinity one bits at the top
+              val &= (1 << 57) - 1
+
+              byte |= 0x80 if val != 0
+              unknown_bytes << byte
+              break if val == 0
+            end
 
-            ## END PULL_BYTES
+            unknown_bytes << buff.byteslice(index, value)
+            index += value
           when 5
+            unknown_bytes << buff.byteslice(index, 4)
             index += 4
           else
             raise "unknown wire type #{wire_type}"
           end
+          (@_unknown_fields ||= +"".b) << unknown_bytes
           return self if index >= len
           ## PULL_UINT64
           tag =
@@ -7120,22 +7590,42 @@ module Api
       end
 
       val = @r
-      if val != 0
+      if has_r?
         buff << 0x1d
 
         [val].pack("e", buffer: buff)
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      result["color".to_sym] = @color.to_h
-      result["p".to_sym] = @p.to_h
-      result["r".to_sym] = @r
+
+      result[:"color"] = @color.to_h
+      result[:"p"] = @p.to_h
+      result[:"r"] = @r
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      result["color"] = @color.nil? ? {} : @color.as_json(options) if !options[
+        :compact
+      ] || has_color?
+      result["p"] = @p.nil? ? {} : @p.as_json(options) if !options[:compact] ||
+        has_p?
+      result["r"] = @r if !options[:compact] || has_r?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class DebugCreateUnit
     def self.decode(buff)
@@ -7326,20 +7816,39 @@ module Api
         # unexpected, so discard it and continue.
         if !found
           wire_type = tag & 0x7
+
+          unknown_bytes = +"".b
+          val = tag
+          loop do
+            byte = val & 0x7F
+
+            val >>= 7
+            # This drops the top bits,
+            # Otherwise, with a signed right shift,
+            # we get infinity one bits at the top
+            val &= (1 << 57) - 1
+
+            byte |= 0x80 if val != 0
+            unknown_bytes << byte
+            break if val == 0
+          end
+
           case wire_type
           when 0
             i = 0
             while true
               newbyte = buff.getbyte(index)
               index += 1
-              break if newbyte.nil? || newbyte < 0x80
+              break if newbyte.nil?
+              unknown_bytes << newbyte
+              break if newbyte < 0x80
               i += 1
               break if i > 9
             end
           when 1
+            unknown_bytes << buff.byteslice(index, 8)
             index += 8
           when 2
-            ## PULL_BYTES
             value =
               if (byte0 = buff.getbyte(index)) < 0x80
                 index += 1
@@ -7395,15 +7904,30 @@ module Api
                 raise "integer decoding error"
               end
 
-            buff.byteslice(index, value)
-            index += value
+            val = value
+            loop do
+              byte = val & 0x7F
+
+              val >>= 7
+              # This drops the top bits,
+              # Otherwise, with a signed right shift,
+              # we get infinity one bits at the top
+              val &= (1 << 57) - 1
+
+              byte |= 0x80 if val != 0
+              unknown_bytes << byte
+              break if val == 0
+            end
 
-            ## END PULL_BYTES
+            unknown_bytes << buff.byteslice(index, value)
+            index += value
           when 5
+            unknown_bytes << buff.byteslice(index, 4)
             index += 4
           else
             raise "unknown wire type #{wire_type}"
           end
+          (@_unknown_fields ||= +"".b) << unknown_bytes
           return self if index >= len
           ## PULL_UINT64
           tag =
@@ -7914,22 +8438,23 @@ module Api
     end
     def _encode(buff)
       val = @unit_type
-      if val != 0
+      if has_unit_type?
         buff << 0x08
 
-        while val != 0
+        loop do
           byte = val & 0x7F
           val >>= 7
           byte |= 0x80 if val > 0
           buff << byte
+          break if val == 0
         end
       end
 
       val = @owner
-      if val != 0
+      if has_owner?
         buff << 0x10
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -7940,6 +8465,7 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
@@ -7992,28 +8518,49 @@ module Api
       end
 
       val = @quantity
-      if val != 0
+      if has_quantity?
         buff << 0x20
 
-        while val != 0
+        loop do
           byte = val & 0x7F
           val >>= 7
           byte |= 0x80 if val > 0
           buff << byte
+          break if val == 0
         end
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      result["unit_type".to_sym] = @unit_type
-      result["owner".to_sym] = @owner
-      result["pos".to_sym] = @pos.to_h
-      result["quantity".to_sym] = @quantity
+
+      result[:"unit_type"] = @unit_type
+      result[:"owner"] = @owner
+      result[:"pos"] = @pos.to_h
+      result[:"quantity"] = @quantity
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      result["unitType"] = @unit_type if !options[:compact] || has_unit_type?
+      result["owner"] = @owner if !options[:compact] || has_owner?
+      result["pos"] = @pos.nil? ? {} : @pos.as_json(options) if !options[
+        :compact
+      ] || has_pos?
+      result["quantity"] = @quantity if !options[:compact] || has_quantity?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class DebugKillUnit
     def self.decode(buff)
@@ -8114,20 +8661,39 @@ module Api
         # unexpected, so discard it and continue.
         if !found
           wire_type = tag & 0x7
+
+          unknown_bytes = +"".b
+          val = tag
+          loop do
+            byte = val & 0x7F
+
+            val >>= 7
+            # This drops the top bits,
+            # Otherwise, with a signed right shift,
+            # we get infinity one bits at the top
+            val &= (1 << 57) - 1
+
+            byte |= 0x80 if val != 0
+            unknown_bytes << byte
+            break if val == 0
+          end
+
           case wire_type
           when 0
             i = 0
             while true
               newbyte = buff.getbyte(index)
               index += 1
-              break if newbyte.nil? || newbyte < 0x80
+              break if newbyte.nil?
+              unknown_bytes << newbyte
+              break if newbyte < 0x80
               i += 1
               break if i > 9
             end
           when 1
+            unknown_bytes << buff.byteslice(index, 8)
             index += 8
           when 2
-            ## PULL_BYTES
             value =
               if (byte0 = buff.getbyte(index)) < 0x80
                 index += 1
@@ -8183,15 +8749,30 @@ module Api
                 raise "integer decoding error"
               end
 
-            buff.byteslice(index, value)
-            index += value
+            val = value
+            loop do
+              byte = val & 0x7F
+
+              val >>= 7
+              # This drops the top bits,
+              # Otherwise, with a signed right shift,
+              # we get infinity one bits at the top
+              val &= (1 << 57) - 1
+
+              byte |= 0x80 if val != 0
+              unknown_bytes << byte
+              break if val == 0
+            end
 
-            ## END PULL_BYTES
+            unknown_bytes << buff.byteslice(index, value)
+            index += value
           when 5
+            unknown_bytes << buff.byteslice(index, 4)
             index += 4
           else
             raise "unknown wire type #{wire_type}"
           end
+          (@_unknown_fields ||= +"".b) << unknown_bytes
           return self if index >= len
           ## PULL_UINT64
           tag =
@@ -8247,11 +8828,13 @@ module Api
         end
         found = false
 
-        if tag == 0xa
+        if tag == 0x8
           found = true
-          ## PULL_UINT64
-          value =
-            if (byte0 = buff.getbyte(index)) < 0x80
+          ## DECODE REPEATED
+          list = @tag
+          while true
+            ## PULL_UINT64
+            list << if (byte0 = buff.getbyte(index)) < 0x80
               index += 1
               byte0
             elsif (byte1 = buff.getbyte(index + 1)) < 0x80
@@ -8299,116 +8882,72 @@ module Api
               raise "integer decoding error"
             end
 
-          ## END PULL_UINT64
+            ## END PULL_UINT64
 
-          goal = index + value
-          list = @tag
-          while true
-            break if index >= goal
+            return self if index >= len
             ## PULL_UINT64
-            list << if (byte0 = buff.getbyte(index)) < 0x80
-              index += 1
-              byte0
-            elsif (byte1 = buff.getbyte(index + 1)) < 0x80
-              index += 2
-              (byte1 << 7) | (byte0 & 0x7F)
-            elsif (byte2 = buff.getbyte(index + 2)) < 0x80
-              index += 3
-              (byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
-            elsif (byte3 = buff.getbyte(index + 3)) < 0x80
-              index += 4
-              (byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
-                (byte0 & 0x7F)
-            elsif (byte4 = buff.getbyte(index + 4)) < 0x80
-              index += 5
-              (byte4 << 28) | ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
-                ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
-            elsif (byte5 = buff.getbyte(index + 5)) < 0x80
-              index += 6
-              (byte5 << 35) | ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
-                ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
-            elsif (byte6 = buff.getbyte(index + 6)) < 0x80
-              index += 7
-              (byte6 << 42) | ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
-                ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
-                ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
-            elsif (byte7 = buff.getbyte(index + 7)) < 0x80
-              index += 8
-              (byte7 << 49) | ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
-                ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
-                ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
-            elsif (byte8 = buff.getbyte(index + 8)) < 0x80
-              index += 9
-              (byte8 << 56) | ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
-                ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
-                ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
-                ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
-            elsif (byte9 = buff.getbyte(index + 9)) < 0x80
-              index += 10
+            tag =
+              if (byte0 = buff.getbyte(index)) < 0x80
+                index += 1
+                byte0
+              elsif (byte1 = buff.getbyte(index + 1)) < 0x80
+                index += 2
+                (byte1 << 7) | (byte0 & 0x7F)
+              elsif (byte2 = buff.getbyte(index + 2)) < 0x80
+                index += 3
+                (byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
+              elsif (byte3 = buff.getbyte(index + 3)) < 0x80
+                index += 4
+                (byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
+                  (byte0 & 0x7F)
+              elsif (byte4 = buff.getbyte(index + 4)) < 0x80
+                index += 5
+                (byte4 << 28) | ((byte3 & 0x7F) << 21) |
+                  ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
+                  (byte0 & 0x7F)
+              elsif (byte5 = buff.getbyte(index + 5)) < 0x80
+                index += 6
+                (byte5 << 35) | ((byte4 & 0x7F) << 28) |
+                  ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
+                  ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
+              elsif (byte6 = buff.getbyte(index + 6)) < 0x80
+                index += 7
+                (byte6 << 42) | ((byte5 & 0x7F) << 35) |
+                  ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
+                  ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
+                  (byte0 & 0x7F)
+              elsif (byte7 = buff.getbyte(index + 7)) < 0x80
+                index += 8
+                (byte7 << 49) | ((byte6 & 0x7F) << 42) |
+                  ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
+                  ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
+                  ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
+              elsif (byte8 = buff.getbyte(index + 8)) < 0x80
+                index += 9
+                (byte8 << 56) | ((byte7 & 0x7F) << 49) |
+                  ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
+                  ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
+                  ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
+                  (byte0 & 0x7F)
+              elsif (byte9 = buff.getbyte(index + 9)) < 0x80
+                index += 10
 
-              (byte9 << 63) | ((byte8 & 0x7F) << 56) | ((byte7 & 0x7F) << 49) |
-                ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
-                ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
-                ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
-            else
-              raise "integer decoding error"
-            end
+                (byte9 << 63) | ((byte8 & 0x7F) << 56) |
+                  ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
+                  ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
+                  ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
+                  ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
+              else
+                raise "integer decoding error"
+              end
 
             ## END PULL_UINT64
+
+            break unless tag == 0x8
           end
+          ## END DECODE REPEATED
 
           return self if index >= len
-          ## PULL_UINT64
-          tag =
-            if (byte0 = buff.getbyte(index)) < 0x80
-              index += 1
-              byte0
-            elsif (byte1 = buff.getbyte(index + 1)) < 0x80
-              index += 2
-              (byte1 << 7) | (byte0 & 0x7F)
-            elsif (byte2 = buff.getbyte(index + 2)) < 0x80
-              index += 3
-              (byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
-            elsif (byte3 = buff.getbyte(index + 3)) < 0x80
-              index += 4
-              (byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
-                (byte0 & 0x7F)
-            elsif (byte4 = buff.getbyte(index + 4)) < 0x80
-              index += 5
-              (byte4 << 28) | ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
-                ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
-            elsif (byte5 = buff.getbyte(index + 5)) < 0x80
-              index += 6
-              (byte5 << 35) | ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
-                ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
-            elsif (byte6 = buff.getbyte(index + 6)) < 0x80
-              index += 7
-              (byte6 << 42) | ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
-                ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
-                ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
-            elsif (byte7 = buff.getbyte(index + 7)) < 0x80
-              index += 8
-              (byte7 << 49) | ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
-                ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
-                ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
-            elsif (byte8 = buff.getbyte(index + 8)) < 0x80
-              index += 9
-              (byte8 << 56) | ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
-                ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
-                ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
-                ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
-            elsif (byte9 = buff.getbyte(index + 9)) < 0x80
-              index += 10
-
-              (byte9 << 63) | ((byte8 & 0x7F) << 56) | ((byte7 & 0x7F) << 49) |
-                ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
-                ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
-                ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
-            else
-              raise "integer decoding error"
-            end
-
-          ## END PULL_UINT64
         end
 
         return self if index >= len
@@ -8417,69 +8956,46 @@ module Api
     def _encode(buff)
       list = @tag
       if list.size > 0
-        buff << 0x0a
-
-        # Save the buffer size before appending the repeated bytes
-        current_len = buff.bytesize
-
-        # Write a single dummy byte to later store encoded length
-        buff << 42 # "*"
-
-        # write each item
         list.each do |item|
           val = item
           if val != 0
-            while val != 0
+            buff << 0x08
+
+            loop do
               byte = val & 0x7F
               val >>= 7
               byte |= 0x80 if val > 0
               buff << byte
+              break if val == 0
             end
           end
         end
+      end
+      buff << @_unknown_fields if @_unknown_fields
+      buff
+    end
 
-        # Calculate the submessage's size
-        submessage_size = buff.bytesize - current_len - 1
+    def to_h
+      result = {}
 
-        # Hope the size fits in one byte
-        byte = submessage_size & 0x7F
-        submessage_size >>= 7
-        byte |= 0x80 if submessage_size > 0
-        buff.setbyte(current_len, byte)
+      result[:"tag"] = @tag
 
-        # If the sub message was bigger
-        if submessage_size > 0
-          current_len += 1
+      result
+    end
 
-          # compute how much we need to shift
-          encoded_int_len = 0
-          remaining_size = submessage_size
-          while remaining_size != 0
-            remaining_size >>= 7
-            encoded_int_len += 1
-          end
+    def as_json(options = {})
+      result = {}
 
-          # Make space in the string with dummy bytes
-          buff.bytesplice(current_len, 0, "*********", 0, encoded_int_len)
+      tmp_tag = @tag
 
-          # Overwrite the dummy bytes with the encoded length
-          while submessage_size != 0
-            byte = submessage_size & 0x7F
-            submessage_size >>= 7
-            byte |= 0x80 if submessage_size > 0
-            buff.setbyte(current_len, byte)
-            current_len += 1
-          end
-        end
-      end
+      result["tag"] = tmp_tag if !options[:compact] || tmp_tag.any?
 
-      buff
+      result
     end
 
-    def to_h
-      result = {}
-      result["tag".to_sym] = @tag
-      result
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
     end
   end
   class DebugTestProcess
@@ -8497,27 +9013,17 @@ module Api
       EXIT = 3
 
       def self.lookup(val)
-        if val == 0
-          :ENUM_TEST_UNSET
-        elsif val == 1
-          :HANG
-        elsif val == 2
-          :CRASH
-        elsif val == 3
-          :EXIT
-        end
+        return :ENUM_TEST_UNSET if val == 0
+        return :HANG if val == 1
+        return :CRASH if val == 2
+        return :EXIT if val == 3
       end
 
       def self.resolve(val)
-        if val == :ENUM_TEST_UNSET
-          0
-        elsif val == :HANG
-          1
-        elsif val == :CRASH
-          2
-        elsif val == :EXIT
-          3
-        end
+        return 0 if val == :ENUM_TEST_UNSET
+        return 1 if val == :HANG
+        return 2 if val == :CRASH
+        return 3 if val == :EXIT
       end
     end
     # required field readers
@@ -8533,6 +9039,7 @@ module Api
     # enum writers
     def test=(v)
       @test = Api::DebugTestProcess::Test.resolve(v) || v
+      @_bitmask |= 0x0000000000000001
     end
 
     # BEGIN writers for optional fields
@@ -8574,6 +9081,10 @@ module Api
       self.class.encode(self)
     end
 
+    def has_test?
+      (@_bitmask & 0x0000000000000001) == 0x0000000000000001
+    end
+
     def has_delay_ms?
       (@_bitmask & 0x0000000000000002) == 0x0000000000000002
     end
@@ -8643,20 +9154,39 @@ module Api
         # unexpected, so discard it and continue.
         if !found
           wire_type = tag & 0x7
+
+          unknown_bytes = +"".b
+          val = tag
+          loop do
+            byte = val & 0x7F
+
+            val >>= 7
+            # This drops the top bits,
+            # Otherwise, with a signed right shift,
+            # we get infinity one bits at the top
+            val &= (1 << 57) - 1
+
+            byte |= 0x80 if val != 0
+            unknown_bytes << byte
+            break if val == 0
+          end
+
           case wire_type
           when 0
             i = 0
             while true
               newbyte = buff.getbyte(index)
               index += 1
-              break if newbyte.nil? || newbyte < 0x80
+              break if newbyte.nil?
+              unknown_bytes << newbyte
+              break if newbyte < 0x80
               i += 1
               break if i > 9
             end
           when 1
+            unknown_bytes << buff.byteslice(index, 8)
             index += 8
           when 2
-            ## PULL_BYTES
             value =
               if (byte0 = buff.getbyte(index)) < 0x80
                 index += 1
@@ -8712,15 +9242,30 @@ module Api
                 raise "integer decoding error"
               end
 
-            buff.byteslice(index, value)
-            index += value
+            val = value
+            loop do
+              byte = val & 0x7F
+
+              val >>= 7
+              # This drops the top bits,
+              # Otherwise, with a signed right shift,
+              # we get infinity one bits at the top
+              val &= (1 << 57) - 1
+
+              byte |= 0x80 if val != 0
+              unknown_bytes << byte
+              break if val == 0
+            end
 
-            ## END PULL_BYTES
+            unknown_bytes << buff.byteslice(index, value)
+            index += value
           when 5
+            unknown_bytes << buff.byteslice(index, 4)
             index += 4
           else
             raise "unknown wire type #{wire_type}"
           end
+          (@_unknown_fields ||= +"".b) << unknown_bytes
           return self if index >= len
           ## PULL_UINT64
           tag =
@@ -9022,10 +9567,10 @@ module Api
     end
     def _encode(buff)
       val = @test
-      if val != 0
+      if has_test?
         buff << 0x08
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -9036,14 +9581,15 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
       val = @delay_ms
-      if val != 0
+      if has_delay_ms?
         buff << 0x10
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -9054,18 +9600,35 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      result["test".to_sym] = @test
-      result["delay_ms".to_sym] = @delay_ms
+
+      result[:"test"] = @test
+      result[:"delay_ms"] = @delay_ms
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      result["test"] = @test if !options[:compact] || has_test?
+      result["delayMs"] = @delay_ms if !options[:compact] || has_delay_ms?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class DebugSetScore
     def self.decode(buff)
@@ -9172,20 +9735,39 @@ module Api
         # unexpected, so discard it and continue.
         if !found
           wire_type = tag & 0x7
+
+          unknown_bytes = +"".b
+          val = tag
+          loop do
+            byte = val & 0x7F
+
+            val >>= 7
+            # This drops the top bits,
+            # Otherwise, with a signed right shift,
+            # we get infinity one bits at the top
+            val &= (1 << 57) - 1
+
+            byte |= 0x80 if val != 0
+            unknown_bytes << byte
+            break if val == 0
+          end
+
           case wire_type
           when 0
             i = 0
             while true
               newbyte = buff.getbyte(index)
               index += 1
-              break if newbyte.nil? || newbyte < 0x80
+              break if newbyte.nil?
+              unknown_bytes << newbyte
+              break if newbyte < 0x80
               i += 1
               break if i > 9
             end
           when 1
+            unknown_bytes << buff.byteslice(index, 8)
             index += 8
           when 2
-            ## PULL_BYTES
             value =
               if (byte0 = buff.getbyte(index)) < 0x80
                 index += 1
@@ -9241,15 +9823,30 @@ module Api
                 raise "integer decoding error"
               end
 
-            buff.byteslice(index, value)
-            index += value
+            val = value
+            loop do
+              byte = val & 0x7F
+
+              val >>= 7
+              # This drops the top bits,
+              # Otherwise, with a signed right shift,
+              # we get infinity one bits at the top
+              val &= (1 << 57) - 1
+
+              byte |= 0x80 if val != 0
+              unknown_bytes << byte
+              break if val == 0
+            end
 
-            ## END PULL_BYTES
+            unknown_bytes << buff.byteslice(index, value)
+            index += value
           when 5
+            unknown_bytes << buff.byteslice(index, 4)
             index += 4
           else
             raise "unknown wire type #{wire_type}"
           end
+          (@_unknown_fields ||= +"".b) << unknown_bytes
           return self if index >= len
           ## PULL_UINT64
           tag =
@@ -9369,20 +9966,35 @@ module Api
     end
     def _encode(buff)
       val = @score
-      if val != 0
+      if has_score?
         buff << 0x0d
 
         [val].pack("e", buffer: buff)
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      result["score".to_sym] = @score
+
+      result[:"score"] = @score
+
       result
     end
+
+    def as_json(options = {})
+      result = {}
+
+      result["score"] = @score if !options[:compact] || has_score?
+
+      result
+    end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class DebugEndGame
     def self.decode(buff)
@@ -9398,23 +10010,15 @@ module Api
       DECLARE_VICTORY = 2
 
       def self.lookup(val)
-        if val == 0
-          :ENUM_END_RESULT_UNSET
-        elsif val == 1
-          :SURRENDER
-        elsif val == 2
-          :DECLARE_VICTORY
-        end
+        return :ENUM_END_RESULT_UNSET if val == 0
+        return :SURRENDER if val == 1
+        return :DECLARE_VICTORY if val == 2
       end
 
       def self.resolve(val)
-        if val == :ENUM_END_RESULT_UNSET
-          0
-        elsif val == :SURRENDER
-          1
-        elsif val == :DECLARE_VICTORY
-          2
-        end
+        return 0 if val == :ENUM_END_RESULT_UNSET
+        return 1 if val == :SURRENDER
+        return 2 if val == :DECLARE_VICTORY
       end
     end
     # required field readers
@@ -9426,9 +10030,12 @@ module Api
     # enum writers
     def end_result=(v)
       @end_result = Api::DebugEndGame::EndResult.resolve(v) || v
+      @_bitmask |= 0x0000000000000001
     end
 
     def initialize(end_result: nil)
+      @_bitmask = 0
+
       if end_result == nil
         @end_result = 0
       else
@@ -9442,7 +10049,13 @@ module Api
       self.class.encode(self)
     end
 
+    def has_end_result?
+      (@_bitmask & 0x0000000000000001) == 0x0000000000000001
+    end
+
     def decode_from(buff, index, len)
+      @_bitmask = 0
+
       @end_result = 0
 
       return self if index >= len
@@ -9504,20 +10117,39 @@ module Api
         # unexpected, so discard it and continue.
         if !found
           wire_type = tag & 0x7
+
+          unknown_bytes = +"".b
+          val = tag
+          loop do
+            byte = val & 0x7F
+
+            val >>= 7
+            # This drops the top bits,
+            # Otherwise, with a signed right shift,
+            # we get infinity one bits at the top
+            val &= (1 << 57) - 1
+
+            byte |= 0x80 if val != 0
+            unknown_bytes << byte
+            break if val == 0
+          end
+
           case wire_type
           when 0
             i = 0
             while true
               newbyte = buff.getbyte(index)
               index += 1
-              break if newbyte.nil? || newbyte < 0x80
+              break if newbyte.nil?
+              unknown_bytes << newbyte
+              break if newbyte < 0x80
               i += 1
               break if i > 9
             end
           when 1
+            unknown_bytes << buff.byteslice(index, 8)
             index += 8
           when 2
-            ## PULL_BYTES
             value =
               if (byte0 = buff.getbyte(index)) < 0x80
                 index += 1
@@ -9573,15 +10205,30 @@ module Api
                 raise "integer decoding error"
               end
 
-            buff.byteslice(index, value)
-            index += value
+            val = value
+            loop do
+              byte = val & 0x7F
+
+              val >>= 7
+              # This drops the top bits,
+              # Otherwise, with a signed right shift,
+              # we get infinity one bits at the top
+              val &= (1 << 57) - 1
+
+              byte |= 0x80 if val != 0
+              unknown_bytes << byte
+              break if val == 0
+            end
 
-            ## END PULL_BYTES
+            unknown_bytes << buff.byteslice(index, value)
+            index += value
           when 5
+            unknown_bytes << buff.byteslice(index, 4)
             index += 4
           else
             raise "unknown wire type #{wire_type}"
           end
+          (@_unknown_fields ||= +"".b) << unknown_bytes
           return self if index >= len
           ## PULL_UINT64
           tag =
@@ -9763,10 +10410,10 @@ module Api
     end
     def _encode(buff)
       val = @end_result
-      if val != 0
+      if has_end_result?
         buff << 0x08
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -9777,17 +10424,33 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      result["end_result".to_sym] = @end_result
+
+      result[:"end_result"] = @end_result
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      result["endResult"] = @end_result if !options[:compact] || has_end_result?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class DebugSetUnitValue
     def self.decode(buff)
@@ -9804,27 +10467,17 @@ module Api
       SHIELDS = 3
 
       def self.lookup(val)
-        if val == 0
-          :ENUM_UNIT_VALUE_UNSET
-        elsif val == 1
-          :ENERGY
-        elsif val == 2
-          :LIFE
-        elsif val == 3
-          :SHIELDS
-        end
+        return :ENUM_UNIT_VALUE_UNSET if val == 0
+        return :ENERGY if val == 1
+        return :LIFE if val == 2
+        return :SHIELDS if val == 3
       end
 
       def self.resolve(val)
-        if val == :ENUM_UNIT_VALUE_UNSET
-          0
-        elsif val == :ENERGY
-          1
-        elsif val == :LIFE
-          2
-        elsif val == :SHIELDS
-          3
-        end
+        return 0 if val == :ENUM_UNIT_VALUE_UNSET
+        return 1 if val == :ENERGY
+        return 2 if val == :LIFE
+        return 3 if val == :SHIELDS
       end
     end
     # required field readers
@@ -9842,6 +10495,7 @@ module Api
     # enum writers
     def unit_value=(v)
       @unit_value = Api::DebugSetUnitValue::UnitValue.resolve(v) || v
+      @_bitmask |= 0x0000000000000001
     end
 
     # BEGIN writers for optional fields
@@ -9896,6 +10550,10 @@ module Api
       self.class.encode(self)
     end
 
+    def has_unit_value?
+      (@_bitmask & 0x0000000000000001) == 0x0000000000000001
+    end
+
     def has_value?
       (@_bitmask & 0x0000000000000002) == 0x0000000000000002
     end
@@ -9970,20 +10628,39 @@ module Api
         # unexpected, so discard it and continue.
         if !found
           wire_type = tag & 0x7
+
+          unknown_bytes = +"".b
+          val = tag
+          loop do
+            byte = val & 0x7F
+
+            val >>= 7
+            # This drops the top bits,
+            # Otherwise, with a signed right shift,
+            # we get infinity one bits at the top
+            val &= (1 << 57) - 1
+
+            byte |= 0x80 if val != 0
+            unknown_bytes << byte
+            break if val == 0
+          end
+
           case wire_type
           when 0
             i = 0
             while true
               newbyte = buff.getbyte(index)
               index += 1
-              break if newbyte.nil? || newbyte < 0x80
+              break if newbyte.nil?
+              unknown_bytes << newbyte
+              break if newbyte < 0x80
               i += 1
               break if i > 9
             end
           when 1
+            unknown_bytes << buff.byteslice(index, 8)
             index += 8
           when 2
-            ## PULL_BYTES
             value =
               if (byte0 = buff.getbyte(index)) < 0x80
                 index += 1
@@ -10039,15 +10716,30 @@ module Api
                 raise "integer decoding error"
               end
 
-            buff.byteslice(index, value)
-            index += value
+            val = value
+            loop do
+              byte = val & 0x7F
+
+              val >>= 7
+              # This drops the top bits,
+              # Otherwise, with a signed right shift,
+              # we get infinity one bits at the top
+              val &= (1 << 57) - 1
+
+              byte |= 0x80 if val != 0
+              unknown_bytes << byte
+              break if val == 0
+            end
 
-            ## END PULL_BYTES
+            unknown_bytes << buff.byteslice(index, value)
+            index += value
           when 5
+            unknown_bytes << buff.byteslice(index, 4)
             index += 4
           else
             raise "unknown wire type #{wire_type}"
           end
+          (@_unknown_fields ||= +"".b) << unknown_bytes
           return self if index >= len
           ## PULL_UINT64
           tag =
@@ -10395,10 +11087,10 @@ module Api
     end
     def _encode(buff)
       val = @unit_value
-      if val != 0
+      if has_unit_value?
         buff << 0x08
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -10409,37 +11101,56 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
       val = @value
-      if val != 0
+      if has_value?
         buff << 0x15
 
         [val].pack("e", buffer: buff)
       end
 
       val = @unit_tag
-      if val != 0
+      if has_unit_tag?
         buff << 0x18
 
-        while val != 0
+        loop do
           byte = val & 0x7F
           val >>= 7
           byte |= 0x80 if val > 0
           buff << byte
+          break if val == 0
         end
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      result["unit_value".to_sym] = @unit_value
-      result["value".to_sym] = @value
-      result["unit_tag".to_sym] = @unit_tag
+
+      result[:"unit_value"] = @unit_value
+      result[:"value"] = @value
+      result[:"unit_tag"] = @unit_tag
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      result["unitValue"] = @unit_value if !options[:compact] || has_unit_value?
+      result["value"] = @value if !options[:compact] || has_value?
+      result["unitTag"] = @unit_tag if !options[:compact] || has_unit_tag?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
 end