sc2ai 0.4.2 → 0.5.0

data/lib/sc2ai/protocol/raw_pb.rb

@@ -11,31 +11,19 @@ module Api
     PLACEHOLDER = 4
 
     def self.lookup(val)
-      if val == 0
-        :ENUM_DISPLAY_TYPE_UNSET
-      elsif val == 1
-        :VISIBLE
-      elsif val == 2
-        :SNAPSHOT
-      elsif val == 3
-        :HIDDEN
-      elsif val == 4
-        :PLACEHOLDER
-      end
+      return :ENUM_DISPLAY_TYPE_UNSET if val == 0
+      return :VISIBLE if val == 1
+      return :SNAPSHOT if val == 2
+      return :HIDDEN if val == 3
+      return :PLACEHOLDER if val == 4
     end
 
     def self.resolve(val)
-      if val == :ENUM_DISPLAY_TYPE_UNSET
-        0
-      elsif val == :VISIBLE
-        1
-      elsif val == :SNAPSHOT
-        2
-      elsif val == :HIDDEN
-        3
-      elsif val == :PLACEHOLDER
-        4
-      end
+      return 0 if val == :ENUM_DISPLAY_TYPE_UNSET
+      return 1 if val == :VISIBLE
+      return 2 if val == :SNAPSHOT
+      return 3 if val == :HIDDEN
+      return 4 if val == :PLACEHOLDER
     end
   end
   module Alliance
@@ -46,31 +34,19 @@ module Api
     ENEMY = 4
 
     def self.lookup(val)
-      if val == 0
-        :ENUM_ALLIANCE_UNSET
-      elsif val == 1
-        :SELF
-      elsif val == 2
-        :ALLY
-      elsif val == 3
-        :NEUTRAL
-      elsif val == 4
-        :ENEMY
-      end
+      return :ENUM_ALLIANCE_UNSET if val == 0
+      return :SELF if val == 1
+      return :ALLY if val == 2
+      return :NEUTRAL if val == 3
+      return :ENEMY if val == 4
     end
 
     def self.resolve(val)
-      if val == :ENUM_ALLIANCE_UNSET
-        0
-      elsif val == :SELF
-        1
-      elsif val == :ALLY
-        2
-      elsif val == :NEUTRAL
-        3
-      elsif val == :ENEMY
-        4
-      end
+      return 0 if val == :ENUM_ALLIANCE_UNSET
+      return 1 if val == :SELF
+      return 2 if val == :ALLY
+      return 3 if val == :NEUTRAL
+      return 4 if val == :ENEMY
     end
   end
   module CloakState
@@ -81,31 +57,19 @@ module Api
     CLOAKED_ALLIED = 4
 
     def self.lookup(val)
-      if val == 0
-        :CLOAKED_UNKNOWN
-      elsif val == 1
-        :CLOAKED
-      elsif val == 2
-        :CLOAKED_DETECTED
-      elsif val == 3
-        :NOT_CLOAKED
-      elsif val == 4
-        :CLOAKED_ALLIED
-      end
+      return :CLOAKED_UNKNOWN if val == 0
+      return :CLOAKED if val == 1
+      return :CLOAKED_DETECTED if val == 2
+      return :NOT_CLOAKED if val == 3
+      return :CLOAKED_ALLIED if val == 4
     end
 
     def self.resolve(val)
-      if val == :CLOAKED_UNKNOWN
-        0
-      elsif val == :CLOAKED
-        1
-      elsif val == :CLOAKED_DETECTED
-        2
-      elsif val == :NOT_CLOAKED
-        3
-      elsif val == :CLOAKED_ALLIED
-        4
-      end
+      return 0 if val == :CLOAKED_UNKNOWN
+      return 1 if val == :CLOAKED
+      return 2 if val == :CLOAKED_DETECTED
+      return 3 if val == :NOT_CLOAKED
+      return 4 if val == :CLOAKED_ALLIED
     end
   end
 
@@ -306,20 +270,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
@@ -375,15 +358,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 =
@@ -1437,20 +1435,73 @@ module Api
           end
         end
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      result["map_size".to_sym] = @map_size.to_h
-      result["pathing_grid".to_sym] = @pathing_grid.to_h
-      result["terrain_height".to_sym] = @terrain_height.to_h
-      result["placement_grid".to_sym] = @placement_grid.to_h
-      result["playable_area".to_sym] = @playable_area.to_h
-      result["start_locations".to_sym] = @start_locations
+
+      result[:"map_size"] = @map_size.to_h
+      result[:"pathing_grid"] = @pathing_grid.to_h
+      result[:"terrain_height"] = @terrain_height.to_h
+      result[:"placement_grid"] = @placement_grid.to_h
+      result[:"playable_area"] = @playable_area.to_h
+      result[:"start_locations"] = @start_locations.map(&:to_h)
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      result["mapSize"] = (
+        if @map_size.nil?
+          {}
+        else
+          @map_size.as_json(options)
+        end
+      ) if !options[:compact] || has_map_size?
+      result["pathingGrid"] = (
+        if @pathing_grid.nil?
+          {}
+        else
+          @pathing_grid.as_json(options)
+        end
+      ) if !options[:compact] || has_pathing_grid?
+      result["terrainHeight"] = (
+        if @terrain_height.nil?
+          {}
+        else
+          @terrain_height.as_json(options)
+        end
+      ) if !options[:compact] || has_terrain_height?
+      result["placementGrid"] = (
+        if @placement_grid.nil?
+          {}
+        else
+          @placement_grid.as_json(options)
+        end
+      ) if !options[:compact] || has_placement_grid?
+      result["playableArea"] = (
+        if @playable_area.nil?
+          {}
+        else
+          @playable_area.as_json(options)
+        end
+      ) if !options[:compact] || has_playable_area?
+      tmp_start_locations = @start_locations.map { |v| v.as_json(options) }
+
+      result["startLocations"] = tmp_start_locations if !options[:compact] ||
+        tmp_start_locations.any?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class ObservationRaw
     def self.decode(buff)
@@ -1629,20 +1680,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
@@ -1698,15 +1768,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 =
@@ -2816,20 +2901,62 @@ module Api
           end
         end
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      result["player".to_sym] = @player.to_h
-      result["units".to_sym] = @units
-      result["map_state".to_sym] = @map_state.to_h
-      result["event".to_sym] = @event.to_h
-      result["effects".to_sym] = @effects
-      result["radar".to_sym] = @radar
+
+      result[:"player"] = @player.to_h
+      result[:"units"] = @units.map(&:to_h)
+      result[:"map_state"] = @map_state.to_h
+      result[:"event"] = @event.to_h
+      result[:"effects"] = @effects.map(&:to_h)
+      result[:"radar"] = @radar.map(&:to_h)
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      result["player"] = (
+        if @player.nil?
+          {}
+        else
+          @player.as_json(options)
+        end
+      ) if !options[:compact] || has_player?
+      tmp_units = @units.map { |v| v.as_json(options) }
+
+      result["units"] = tmp_units if !options[:compact] || tmp_units.any?
+
+      result["mapState"] = (
+        if @map_state.nil?
+          {}
+        else
+          @map_state.as_json(options)
+        end
+      ) if !options[:compact] || has_map_state?
+      result["event"] = @event.nil? ? {} : @event.as_json(options) if !options[
+        :compact
+      ] || has_event?
+      tmp_effects = @effects.map { |v| v.as_json(options) }
+
+      result["effects"] = tmp_effects if !options[:compact] || tmp_effects.any?
+
+      tmp_radar = @radar.map { |v| v.as_json(options) }
+
+      result["radar"] = tmp_radar if !options[:compact] || tmp_radar.any?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class RadarRing
     def self.decode(buff)
@@ -2955,20 +3082,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
@@ -3024,15 +3170,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 =
@@ -3312,21 +3473,39 @@ module Api
       end
 
       val = @radius
-      if val != 0
+      if has_radius?
         buff << 0x15
 
         [val].pack("e", buffer: buff)
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      result["pos".to_sym] = @pos.to_h
-      result["radius".to_sym] = @radius
+
+      result[:"pos"] = @pos.to_h
+      result[:"radius"] = @radius
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      result["pos"] = @pos.nil? ? {} : @pos.as_json(options) if !options[
+        :compact
+      ] || has_pos?
+      result["radius"] = @radius if !options[:compact] || has_radius?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class PowerSource
     def self.decode(buff)
@@ -3480,20 +3659,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
@@ -3549,15 +3747,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 =
@@ -3945,34 +4158,54 @@ module Api
       end
 
       val = @radius
-      if val != 0
+      if has_radius?
         buff << 0x15
 
         [val].pack("e", buffer: buff)
       end
 
       val = @tag
-      if val != 0
+      if has_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["pos".to_sym] = @pos.to_h
-      result["radius".to_sym] = @radius
-      result["tag".to_sym] = @tag
+
+      result[:"pos"] = @pos.to_h
+      result[:"radius"] = @radius
+      result[:"tag"] = @tag
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      result["pos"] = @pos.nil? ? {} : @pos.as_json(options) if !options[
+        :compact
+      ] || has_pos?
+      result["radius"] = @radius if !options[:compact] || has_radius?
+      result["tag"] = @tag if !options[:compact] || has_tag?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class PlayerRaw
     def self.decode(buff)
@@ -4110,20 +4343,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
@@ -4179,15 +4431,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 =
@@ -4492,64 +4759,11 @@ module Api
 
           ## END PULL_UINT64
         end
-        if tag == 0x1a
+        if tag == 0x18
           found = true
-          ## PULL_UINT64
-          value =
-            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
-
-          goal = index + value
+          ## DECODE REPEATED
           list = @upgrade_ids
           while true
-            break if index >= goal
             ## PULL_UINT64
             list << if (byte0 = buff.getbyte(index)) < 0x80
               index += 1
@@ -4600,60 +4814,71 @@ module Api
             end
 
             ## END PULL_UINT64
+
+            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
+
+            break unless tag == 0x18
           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
@@ -4763,72 +4988,62 @@ module Api
 
       list = @upgrade_ids
       if list.size > 0
-        buff << 0x1a
-
-        # 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 << 0x18
+
+            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[:"power_sources"] = @power_sources.map(&:to_h)
+      result[:"camera"] = @camera.to_h
+      result[:"upgrade_ids"] = @upgrade_ids
 
-        # 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_power_sources = @power_sources.map { |v| v.as_json(options) }
 
-          # 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
+      result["powerSources"] = tmp_power_sources if !options[:compact] ||
+        tmp_power_sources.any?
+
+      result["camera"] = (
+        if @camera.nil?
+          {}
+        else
+          @camera.as_json(options)
         end
-      end
+      ) if !options[:compact] || has_camera?
+      tmp_upgrade_ids = @upgrade_ids
 
-      buff
-    end
+      result["upgradeIds"] = tmp_upgrade_ids if !options[:compact] ||
+        tmp_upgrade_ids.any?
 
-    def to_h
-      result = {}
-      result["power_sources".to_sym] = @power_sources
-      result["camera".to_sym] = @camera.to_h
-      result["upgrade_ids".to_sym] = @upgrade_ids
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class UnitOrder
     def self.decode(buff)
@@ -5017,20 +5232,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
@@ -5086,15 +5320,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 =
@@ -5543,14 +5792,15 @@ module Api
     end
     def _encode(buff)
       val = @ability_id
-      if val != 0
+      if has_ability_id?
         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
 
@@ -5606,31 +5856,66 @@ module Api
       if val != 0
         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
 
       val = @progress
-      if val != 0
+      if has_progress?
         buff << 0x25
 
         [val].pack("e", buffer: buff)
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      send("target").tap { |f| result[f.to_sym] = send(f) if f }
-      result["ability_id".to_sym] = @ability_id
-      result["progress".to_sym] = @progress
+
+      resolved_target = self.target
+
+      result[:"ability_id"] = @ability_id
+      result[
+        :"target_world_space_pos"
+      ] = @target_world_space_pos.to_h if resolved_target ==
+        :"target_world_space_pos"
+      result[:"target_unit_tag"] = @target_unit_tag if resolved_target ==
+        :"target_unit_tag"
+      result[:"progress"] = @progress
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      resolved_target = self.target
+
+      result["abilityId"] = @ability_id if !options[:compact] || has_ability_id?
+      result["targetWorldSpacePos"] = (
+        if @target_world_space_pos.nil?
+          {}
+        else
+          @target_world_space_pos.as_json(options)
+        end
+      ) if resolved_target == :"target_world_space_pos"
+      result["targetUnitTag"] = @target_unit_tag if resolved_target ==
+        :"target_unit_tag"
+      result["progress"] = @progress if !options[:compact] || has_progress?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class PassengerUnit
     def self.decode(buff)
@@ -5897,20 +6182,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
@@ -5966,15 +6270,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 =
@@ -6600,86 +6919,110 @@ module Api
     end
     def _encode(buff)
       val = @tag
-      if val != 0
+      if has_tag?
         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 = @health
-      if val != 0
+      if has_health?
         buff << 0x15
 
         [val].pack("e", buffer: buff)
       end
 
       val = @health_max
-      if val != 0
+      if has_health_max?
         buff << 0x1d
 
         [val].pack("e", buffer: buff)
       end
 
       val = @shield
-      if val != 0
+      if has_shield?
         buff << 0x25
 
         [val].pack("e", buffer: buff)
       end
 
       val = @shield_max
-      if val != 0
+      if has_shield_max?
         buff << 0x3d
 
         [val].pack("e", buffer: buff)
       end
 
       val = @energy
-      if val != 0
+      if has_energy?
         buff << 0x2d
 
         [val].pack("e", buffer: buff)
       end
 
       val = @energy_max
-      if val != 0
+      if has_energy_max?
         buff << 0x45
 
         [val].pack("e", buffer: buff)
       end
 
       val = @unit_type
-      if val != 0
+      if has_unit_type?
         buff << 0x30
 
-        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["tag".to_sym] = @tag
-      result["health".to_sym] = @health
-      result["health_max".to_sym] = @health_max
-      result["shield".to_sym] = @shield
-      result["shield_max".to_sym] = @shield_max
-      result["energy".to_sym] = @energy
-      result["energy_max".to_sym] = @energy_max
-      result["unit_type".to_sym] = @unit_type
+
+      result[:"tag"] = @tag
+      result[:"health"] = @health
+      result[:"health_max"] = @health_max
+      result[:"shield"] = @shield
+      result[:"energy"] = @energy
+      result[:"unit_type"] = @unit_type
+      result[:"shield_max"] = @shield_max
+      result[:"energy_max"] = @energy_max
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      result["tag"] = @tag if !options[:compact] || has_tag?
+      result["health"] = @health if !options[:compact] || has_health?
+      result["healthMax"] = @health_max if !options[:compact] || has_health_max?
+      result["shield"] = @shield if !options[:compact] || has_shield?
+      result["energy"] = @energy if !options[:compact] || has_energy?
+      result["unitType"] = @unit_type if !options[:compact] || has_unit_type?
+      result["shieldMax"] = @shield_max if !options[:compact] || has_shield_max?
+      result["energyMax"] = @energy_max if !options[:compact] || has_energy_max?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class RallyTarget
     def self.decode(buff)
@@ -6814,20 +7157,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
@@ -6883,15 +7245,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 =
@@ -7222,26 +7599,45 @@ module Api
       end
 
       val = @tag
-      if val != 0
+      if has_tag?
         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
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      result["point".to_sym] = @point.to_h
-      result["tag".to_sym] = @tag
+
+      result[:"point"] = @point.to_h
+      result[:"tag"] = @tag
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      result["point"] = @point.nil? ? {} : @point.as_json(options) if !options[
+        :compact
+      ] || has_point?
+      result["tag"] = @tag if !options[:compact] || has_tag?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class Unit
     def self.decode(buff)
@@ -7373,12 +7769,15 @@ module Api
     # enum writers
     def display_type=(v)
       @display_type = Api::DisplayType.resolve(v) || v
+      @_bitmask |= 0x0000000000000001
     end
     def alliance=(v)
       @alliance = Api::Alliance.resolve(v) || v
+      @_bitmask |= 0x0000000000000002
     end
     def cloak=(v)
       @cloak = Api::CloakState.resolve(v) || v
+      @_bitmask |= 0x0000000000000200
     end
 
     # BEGIN writers for optional fields
@@ -8072,6 +8471,14 @@ module Api
       self.class.encode(self)
     end
 
+    def has_display_type?
+      (@_bitmask & 0x0000000000000001) == 0x0000000000000001
+    end
+
+    def has_alliance?
+      (@_bitmask & 0x0000000000000002) == 0x0000000000000002
+    end
+
     def has_tag?
       (@_bitmask & 0x0000000000000004) == 0x0000000000000004
     end
@@ -8100,6 +8507,10 @@ module Api
       (@_bitmask & 0x0000000000000100) == 0x0000000000000100
     end
 
+    def has_cloak?
+      (@_bitmask & 0x0000000000000200) == 0x0000000000000200
+    end
+
     def has_detect_range?
       (@_bitmask & 0x0000000000000400) == 0x0000000000000400
     end
@@ -8327,20 +8738,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
@@ -8396,15 +8826,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 =
@@ -9442,64 +9887,11 @@ module Api
 
           ## END PULL_UINT64
         end
-        if tag == 0xda
+        if tag == 0xd8
           found = true
-          ## PULL_UINT64
-          value =
-            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
-
-          goal = index + value
+          ## DECODE REPEATED
           list = @buff_ids
           while true
-            break if index >= goal
             ## PULL_UINT64
             list << if (byte0 = buff.getbyte(index)) < 0x80
               index += 1
@@ -9550,60 +9942,71 @@ module Api
             end
 
             ## END PULL_UINT64
-          end
 
-          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
+            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
+                (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 PULL_UINT64
+
+            break unless tag == 0xd8
+          end
+          ## END DECODE REPEATED
+
+          return self if index >= len
         end
         if tag == 0xfd
           found = true
@@ -12565,10 +12968,10 @@ module Api
     end
     def _encode(buff)
       val = @display_type
-      if val != 0
+      if has_display_type?
         buff << 0x08
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -12579,14 +12982,15 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
       val = @alliance
-      if val != 0
+      if has_alliance?
         buff << 0x10
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -12597,38 +13001,41 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
       val = @tag
-      if val != 0
+      if has_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
 
       val = @unit_type
-      if val != 0
+      if has_unit_type?
         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
 
       val = @owner
-      if val != 0
+      if has_owner?
         buff << 0x28
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -12639,6 +13046,7 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
@@ -12691,31 +13099,31 @@ module Api
       end
 
       val = @facing
-      if val != 0
+      if has_facing?
         buff << 0x3d
 
         [val].pack("e", buffer: buff)
       end
 
       val = @radius
-      if val != 0
+      if has_radius?
         buff << 0x45
 
         [val].pack("e", buffer: buff)
       end
 
       val = @build_progress
-      if val != 0
+      if has_build_progress?
         buff << 0x4d
 
         [val].pack("e", buffer: buff)
       end
 
       val = @cloak
-      if val != 0
+      if has_cloak?
         buff << 0x50
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -12726,70 +13134,31 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
       list = @buff_ids
       if list.size > 0
-        buff << 0xda
-        buff << 0x01
-
-        # 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 << 0xd8
+            buff << 0x01
+
+            loop do
               byte = val & 0x7F
               val >>= 7
               byte |= 0x80 if val > 0
               buff << byte
+              break if val == 0
             end
           end
         end
-
-        # Calculate the submessage's size
-        submessage_size = buff.bytesize - current_len - 1
-
-        # 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)
-
-        # If the sub message was bigger
-        if submessage_size > 0
-          current_len += 1
-
-          # 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
-
-          # Make space in the string with dummy bytes
-          buff.bytesplice(current_len, 0, "*********", 0, encoded_int_len)
-
-          # 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
 
       val = @detect_range
-      if val != 0
+      if has_detect_range?
         buff << 0xfd
         buff << 0x01
 
@@ -12797,76 +13166,76 @@ module Api
       end
 
       val = @radar_range
-      if val != 0
+      if has_radar_range?
         buff << 0x85
         buff << 0x02
 
         [val].pack("e", buffer: buff)
       end
 
-      val = @is_selected
-      if val == true
+      if has_is_selected?
+        val = @is_selected
         buff << 0x58
 
-        buff << 1
-      elsif val == false
-        # Default value, encode nothing
-      else
-        raise "bool values should be true or false"
+        if val == true
+          buff << 1
+        elsif val == false
+          buff << 0
+        end
       end
 
-      val = @is_on_screen
-      if val == true
+      if has_is_on_screen?
+        val = @is_on_screen
         buff << 0x60
 
-        buff << 1
-      elsif val == false
-        # Default value, encode nothing
-      else
-        raise "bool values should be true or false"
+        if val == true
+          buff << 1
+        elsif val == false
+          buff << 0
+        end
       end
 
-      val = @is_blip
-      if val == true
+      if has_is_blip?
+        val = @is_blip
         buff << 0x68
 
-        buff << 1
-      elsif val == false
-        # Default value, encode nothing
-      else
-        raise "bool values should be true or false"
+        if val == true
+          buff << 1
+        elsif val == false
+          buff << 0
+        end
       end
 
-      val = @is_powered
-      if val == true
+      if has_is_powered?
+        val = @is_powered
         buff << 0x98
         buff << 0x02
 
-        buff << 1
-      elsif val == false
-        # Default value, encode nothing
-      else
-        raise "bool values should be true or false"
+        if val == true
+          buff << 1
+        elsif val == false
+          buff << 0
+        end
       end
 
-      val = @is_active
-      if val == true
+      if has_is_active?
+        val = @is_active
         buff << 0xb8
         buff << 0x02
 
-        buff << 1
-      elsif val == false
-        # Default value, encode nothing
-      else
-        raise "bool values should be true or false"
+        if val == true
+          buff << 1
+        elsif val == false
+          buff << 0
+        end
       end
 
       val = @attack_upgrade_level
-      if val != 0
+      if has_attack_upgrade_level?
         buff << 0xc0
         buff << 0x02
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -12877,15 +13246,16 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
       val = @armor_upgrade_level
-      if val != 0
+      if has_armor_upgrade_level?
         buff << 0xc8
         buff << 0x02
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -12896,15 +13266,16 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
       val = @shield_upgrade_level
-      if val != 0
+      if has_shield_upgrade_level?
         buff << 0xd0
         buff << 0x02
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -12915,25 +13286,26 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
       val = @health
-      if val != 0
+      if has_health?
         buff << 0x75
 
         [val].pack("e", buffer: buff)
       end
 
       val = @health_max
-      if val != 0
+      if has_health_max?
         buff << 0x7d
 
         [val].pack("e", buffer: buff)
       end
 
       val = @shield
-      if val != 0
+      if has_shield?
         buff << 0x85
         buff << 0x01
 
@@ -12941,7 +13313,7 @@ module Api
       end
 
       val = @shield_max
-      if val != 0
+      if has_shield_max?
         buff << 0xa5
         buff << 0x02
 
@@ -12949,7 +13321,7 @@ module Api
       end
 
       val = @energy
-      if val != 0
+      if has_energy?
         buff << 0x8d
         buff << 0x01
 
@@ -12957,7 +13329,7 @@ module Api
       end
 
       val = @energy_max
-      if val != 0
+      if has_energy_max?
         buff << 0xad
         buff << 0x02
 
@@ -12965,11 +13337,11 @@ module Api
       end
 
       val = @mineral_contents
-      if val != 0
+      if has_mineral_contents?
         buff << 0x90
         buff << 0x01
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -12980,15 +13352,16 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
       val = @vespene_contents
-      if val != 0
+      if has_vespene_contents?
         buff << 0x98
         buff << 0x01
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -12999,43 +13372,44 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
-      val = @is_flying
-      if val == true
+      if has_is_flying?
+        val = @is_flying
         buff << 0xa0
         buff << 0x01
 
-        buff << 1
-      elsif val == false
-        # Default value, encode nothing
-      else
-        raise "bool values should be true or false"
+        if val == true
+          buff << 1
+        elsif val == false
+          buff << 0
+        end
       end
 
-      val = @is_burrowed
-      if val == true
+      if has_is_burrowed?
+        val = @is_burrowed
         buff << 0xa8
         buff << 0x01
 
-        buff << 1
-      elsif val == false
-        # Default value, encode nothing
-      else
-        raise "bool values should be true or false"
+        if val == true
+          buff << 1
+        elsif val == false
+          buff << 0
+        end
       end
 
-      val = @is_hallucination
-      if val == true
+      if has_is_hallucination?
+        val = @is_hallucination
         buff << 0xb0
         buff << 0x02
 
-        buff << 1
-      elsif val == false
-        # Default value, encode nothing
-      else
-        raise "bool values should be true or false"
+        if val == true
+          buff << 1
+        elsif val == false
+          buff << 0
+        end
       end
 
       list = @orders
@@ -13093,15 +13467,16 @@ module Api
       end
 
       val = @add_on_tag
-      if val != 0
+      if has_add_on_tag?
         buff << 0xb8
         buff << 0x01
 
-        while val != 0
+        loop do
           byte = val & 0x7F
           val >>= 7
           byte |= 0x80 if val > 0
           buff << byte
+          break if val == 0
         end
       end
 
@@ -13160,11 +13535,11 @@ module Api
       end
 
       val = @cargo_space_taken
-      if val != 0
+      if has_cargo_space_taken?
         buff << 0xc8
         buff << 0x01
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -13175,15 +13550,16 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
       val = @cargo_space_max
-      if val != 0
+      if has_cargo_space_max?
         buff << 0xd0
         buff << 0x01
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -13194,15 +13570,16 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
       val = @assigned_harvesters
-      if val != 0
+      if has_assigned_harvesters?
         buff << 0xe0
         buff << 0x01
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -13213,15 +13590,16 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
       val = @ideal_harvesters
-      if val != 0
+      if has_ideal_harvesters?
         buff << 0xe8
         buff << 0x01
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -13232,11 +13610,12 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
       val = @weapon_cooldown
-      if val != 0
+      if has_weapon_cooldown?
         buff << 0xf5
         buff << 0x01
 
@@ -13244,24 +13623,25 @@ module Api
       end
 
       val = @engaged_target_tag
-      if val != 0
+      if has_engaged_target_tag?
         buff << 0x90
         buff << 0x02
 
-        while val != 0
+        loop do
           byte = val & 0x7F
           val >>= 7
           byte |= 0x80 if val > 0
           buff << byte
+          break if val == 0
         end
       end
 
       val = @buff_duration_remain
-      if val != 0
+      if has_buff_duration_remain?
         buff << 0xd8
         buff << 0x02
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -13272,15 +13652,16 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
       val = @buff_duration_max
-      if val != 0
+      if has_buff_duration_max?
         buff << 0xe0
         buff << 0x02
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -13291,6 +13672,7 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
@@ -13347,58 +13729,158 @@ module Api
           end
         end
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      result["display_type".to_sym] = @display_type
-      result["alliance".to_sym] = @alliance
-      result["tag".to_sym] = @tag
-      result["unit_type".to_sym] = @unit_type
-      result["owner".to_sym] = @owner
-      result["pos".to_sym] = @pos.to_h
-      result["facing".to_sym] = @facing
-      result["radius".to_sym] = @radius
-      result["build_progress".to_sym] = @build_progress
-      result["cloak".to_sym] = @cloak
-      result["buff_ids".to_sym] = @buff_ids
-      result["detect_range".to_sym] = @detect_range
-      result["radar_range".to_sym] = @radar_range
-      result["is_selected".to_sym] = @is_selected
-      result["is_on_screen".to_sym] = @is_on_screen
-      result["is_blip".to_sym] = @is_blip
-      result["is_powered".to_sym] = @is_powered
-      result["is_active".to_sym] = @is_active
-      result["attack_upgrade_level".to_sym] = @attack_upgrade_level
-      result["armor_upgrade_level".to_sym] = @armor_upgrade_level
-      result["shield_upgrade_level".to_sym] = @shield_upgrade_level
-      result["health".to_sym] = @health
-      result["health_max".to_sym] = @health_max
-      result["shield".to_sym] = @shield
-      result["shield_max".to_sym] = @shield_max
-      result["energy".to_sym] = @energy
-      result["energy_max".to_sym] = @energy_max
-      result["mineral_contents".to_sym] = @mineral_contents
-      result["vespene_contents".to_sym] = @vespene_contents
-      result["is_flying".to_sym] = @is_flying
-      result["is_burrowed".to_sym] = @is_burrowed
-      result["is_hallucination".to_sym] = @is_hallucination
-      result["orders".to_sym] = @orders
-      result["add_on_tag".to_sym] = @add_on_tag
-      result["passengers".to_sym] = @passengers
-      result["cargo_space_taken".to_sym] = @cargo_space_taken
-      result["cargo_space_max".to_sym] = @cargo_space_max
-      result["assigned_harvesters".to_sym] = @assigned_harvesters
-      result["ideal_harvesters".to_sym] = @ideal_harvesters
-      result["weapon_cooldown".to_sym] = @weapon_cooldown
-      result["engaged_target_tag".to_sym] = @engaged_target_tag
-      result["buff_duration_remain".to_sym] = @buff_duration_remain
-      result["buff_duration_max".to_sym] = @buff_duration_max
-      result["rally_targets".to_sym] = @rally_targets
+
+      result[:"display_type"] = @display_type
+      result[:"alliance"] = @alliance
+      result[:"tag"] = @tag
+      result[:"unit_type"] = @unit_type
+      result[:"owner"] = @owner
+      result[:"pos"] = @pos.to_h
+      result[:"facing"] = @facing
+      result[:"radius"] = @radius
+      result[:"build_progress"] = @build_progress
+      result[:"cloak"] = @cloak
+      result[:"is_selected"] = @is_selected
+      result[:"is_on_screen"] = @is_on_screen
+      result[:"is_blip"] = @is_blip
+      result[:"health"] = @health
+      result[:"health_max"] = @health_max
+      result[:"shield"] = @shield
+      result[:"energy"] = @energy
+      result[:"mineral_contents"] = @mineral_contents
+      result[:"vespene_contents"] = @vespene_contents
+      result[:"is_flying"] = @is_flying
+      result[:"is_burrowed"] = @is_burrowed
+      result[:"orders"] = @orders.map(&:to_h)
+      result[:"add_on_tag"] = @add_on_tag
+      result[:"passengers"] = @passengers.map(&:to_h)
+      result[:"cargo_space_taken"] = @cargo_space_taken
+      result[:"cargo_space_max"] = @cargo_space_max
+      result[:"buff_ids"] = @buff_ids
+      result[:"assigned_harvesters"] = @assigned_harvesters
+      result[:"ideal_harvesters"] = @ideal_harvesters
+      result[:"weapon_cooldown"] = @weapon_cooldown
+      result[:"detect_range"] = @detect_range
+      result[:"radar_range"] = @radar_range
+      result[:"engaged_target_tag"] = @engaged_target_tag
+      result[:"is_powered"] = @is_powered
+      result[:"shield_max"] = @shield_max
+      result[:"energy_max"] = @energy_max
+      result[:"is_hallucination"] = @is_hallucination
+      result[:"is_active"] = @is_active
+      result[:"attack_upgrade_level"] = @attack_upgrade_level
+      result[:"armor_upgrade_level"] = @armor_upgrade_level
+      result[:"shield_upgrade_level"] = @shield_upgrade_level
+      result[:"buff_duration_remain"] = @buff_duration_remain
+      result[:"buff_duration_max"] = @buff_duration_max
+      result[:"rally_targets"] = @rally_targets.map(&:to_h)
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      result["displayType"] = @display_type if !options[:compact] ||
+        has_display_type?
+      result["alliance"] = @alliance if !options[:compact] || has_alliance?
+      result["tag"] = @tag if !options[:compact] || has_tag?
+      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["facing"] = @facing if !options[:compact] || has_facing?
+      result["radius"] = @radius if !options[:compact] || has_radius?
+      result["buildProgress"] = @build_progress if !options[:compact] ||
+        has_build_progress?
+      result["cloak"] = @cloak if !options[:compact] || has_cloak?
+      result["isSelected"] = @is_selected if !options[:compact] ||
+        has_is_selected?
+      result["isOnScreen"] = @is_on_screen if !options[:compact] ||
+        has_is_on_screen?
+      result["isBlip"] = @is_blip if !options[:compact] || has_is_blip?
+      result["health"] = @health if !options[:compact] || has_health?
+      result["healthMax"] = @health_max if !options[:compact] || has_health_max?
+      result["shield"] = @shield if !options[:compact] || has_shield?
+      result["energy"] = @energy if !options[:compact] || has_energy?
+      result["mineralContents"] = @mineral_contents if !options[:compact] ||
+        has_mineral_contents?
+      result["vespeneContents"] = @vespene_contents if !options[:compact] ||
+        has_vespene_contents?
+      result["isFlying"] = @is_flying if !options[:compact] || has_is_flying?
+      result["isBurrowed"] = @is_burrowed if !options[:compact] ||
+        has_is_burrowed?
+      tmp_orders = @orders.map { |v| v.as_json(options) }
+
+      result["orders"] = tmp_orders if !options[:compact] || tmp_orders.any?
+
+      result["addOnTag"] = @add_on_tag if !options[:compact] || has_add_on_tag?
+      tmp_passengers = @passengers.map { |v| v.as_json(options) }
+
+      result["passengers"] = tmp_passengers if !options[:compact] ||
+        tmp_passengers.any?
+
+      result["cargoSpaceTaken"] = @cargo_space_taken if !options[:compact] ||
+        has_cargo_space_taken?
+      result["cargoSpaceMax"] = @cargo_space_max if !options[:compact] ||
+        has_cargo_space_max?
+      tmp_buff_ids = @buff_ids
+
+      result["buffIds"] = tmp_buff_ids if !options[:compact] ||
+        tmp_buff_ids.any?
+
+      result["assignedHarvesters"] = @assigned_harvesters if !options[
+        :compact
+      ] || has_assigned_harvesters?
+      result["idealHarvesters"] = @ideal_harvesters if !options[:compact] ||
+        has_ideal_harvesters?
+      result["weaponCooldown"] = @weapon_cooldown if !options[:compact] ||
+        has_weapon_cooldown?
+      result["detectRange"] = @detect_range if !options[:compact] ||
+        has_detect_range?
+      result["radarRange"] = @radar_range if !options[:compact] ||
+        has_radar_range?
+      result["engagedTargetTag"] = @engaged_target_tag if !options[:compact] ||
+        has_engaged_target_tag?
+      result["isPowered"] = @is_powered if !options[:compact] || has_is_powered?
+      result["shieldMax"] = @shield_max if !options[:compact] || has_shield_max?
+      result["energyMax"] = @energy_max if !options[:compact] || has_energy_max?
+      result["isHallucination"] = @is_hallucination if !options[:compact] ||
+        has_is_hallucination?
+      result["isActive"] = @is_active if !options[:compact] || has_is_active?
+      result["attackUpgradeLevel"] = @attack_upgrade_level if !options[
+        :compact
+      ] || has_attack_upgrade_level?
+      result["armorUpgradeLevel"] = @armor_upgrade_level if !options[
+        :compact
+      ] || has_armor_upgrade_level?
+      result["shieldUpgradeLevel"] = @shield_upgrade_level if !options[
+        :compact
+      ] || has_shield_upgrade_level?
+      result["buffDurationRemain"] = @buff_duration_remain if !options[
+        :compact
+      ] || has_buff_duration_remain?
+      result["buffDurationMax"] = @buff_duration_max if !options[:compact] ||
+        has_buff_duration_max?
+      tmp_rally_targets = @rally_targets.map { |v| v.as_json(options) }
+
+      result["rallyTargets"] = tmp_rally_targets if !options[:compact] ||
+        tmp_rally_targets.any?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class MapState
     def self.decode(buff)
@@ -13524,20 +14006,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
@@ -13593,15 +14094,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 =
@@ -13983,16 +14499,40 @@ module Api
 
         buff
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      result["visibility".to_sym] = @visibility.to_h
-      result["creep".to_sym] = @creep.to_h
+
+      result[:"visibility"] = @visibility.to_h
+      result[:"creep"] = @creep.to_h
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      result["visibility"] = (
+        if @visibility.nil?
+          {}
+        else
+          @visibility.as_json(options)
+        end
+      ) if !options[:compact] || has_visibility?
+      result["creep"] = @creep.nil? ? {} : @creep.as_json(options) if !options[
+        :compact
+      ] || has_creep?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class Event
     def self.decode(buff)
@@ -14093,20 +14633,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
@@ -14162,15 +14721,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 =
@@ -14226,11 +14800,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 = @dead_units
+          while true
+            ## PULL_UINT64
+            list << if (byte0 = buff.getbyte(index)) < 0x80
               index += 1
               byte0
             elsif (byte1 = buff.getbyte(index + 1)) < 0x80
@@ -14278,116 +14854,72 @@ module Api
               raise "integer decoding error"
             end
 
-          ## END PULL_UINT64
+            ## END PULL_UINT64
 
-          goal = index + value
-          list = @dead_units
-          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
@@ -14396,69 +14928,47 @@ module Api
     def _encode(buff)
       list = @dead_units
       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[:"dead_units"] = @dead_units
 
-        # 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_dead_units = @dead_units
 
-          # 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["deadUnits"] = tmp_dead_units if !options[:compact] ||
+        tmp_dead_units.any?
 
-      buff
+      result
     end
 
-    def to_h
-      result = {}
-      result["dead_units".to_sym] = @dead_units
-      result
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
     end
   end
   class Effect
@@ -14492,6 +15002,7 @@ module Api
     # enum writers
     def alliance=(v)
       @alliance = Api::Alliance.resolve(v) || v
+      @_bitmask |= 0x0000000000000002
     end
 
     # BEGIN writers for optional fields
@@ -14578,6 +15089,10 @@ module Api
       (@_bitmask & 0x0000000000000001) == 0x0000000000000001
     end
 
+    def has_alliance?
+      (@_bitmask & 0x0000000000000002) == 0x0000000000000002
+    end
+
     def has_owner?
       (@_bitmask & 0x0000000000000004) == 0x0000000000000004
     end
@@ -14654,20 +15169,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
@@ -14723,15 +15257,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 =
@@ -15335,14 +15884,15 @@ module Api
     end
     def _encode(buff)
       val = @effect_id
-      if val != 0
+      if has_effect_id?
         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
 
@@ -15400,10 +15950,10 @@ module Api
       end
 
       val = @alliance
-      if val != 0
+      if has_alliance?
         buff << 0x18
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -15414,14 +15964,15 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
       val = @owner
-      if val != 0
+      if has_owner?
         buff << 0x20
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -15432,28 +15983,51 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
       val = @radius
-      if val != 0
+      if has_radius?
         buff << 0x2d
 
         [val].pack("e", buffer: buff)
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      result["effect_id".to_sym] = @effect_id
-      result["pos".to_sym] = @pos
-      result["alliance".to_sym] = @alliance
-      result["owner".to_sym] = @owner
-      result["radius".to_sym] = @radius
+
+      result[:"effect_id"] = @effect_id
+      result[:"pos"] = @pos.map(&:to_h)
+      result[:"alliance"] = @alliance
+      result[:"owner"] = @owner
+      result[:"radius"] = @radius
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      result["effectId"] = @effect_id if !options[:compact] || has_effect_id?
+      tmp_pos = @pos.map { |v| v.as_json(options) }
+
+      result["pos"] = tmp_pos if !options[:compact] || tmp_pos.any?
+
+      result["alliance"] = @alliance if !options[:compact] || has_alliance?
+      result["owner"] = @owner if !options[:compact] || has_owner?
+      result["radius"] = @radius if !options[:compact] || has_radius?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class ActionRaw
     def self.decode(buff)
@@ -15585,20 +16159,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
@@ -15654,15 +16247,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 =
@@ -16217,29 +16825,73 @@ module Api
 
         buff
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      send("action").tap { |f| result[f.to_sym] = send(f) if f }
-      result
-    end
-  end
-  class ActionRawUnitCommand
-    def self.decode(buff)
-      allocate.decode_from(buff.b, 0, buff.bytesize)
-    end
 
-    def self.encode(obj)
-      obj._encode("".b)
+      resolved_action = self.action
+
+      result[:"unit_command"] = @unit_command.to_h if resolved_action ==
+        :"unit_command"
+      result[:"camera_move"] = @camera_move.to_h if resolved_action ==
+        :"camera_move"
+      result[:"toggle_autocast"] = @toggle_autocast.to_h if resolved_action ==
+        :"toggle_autocast"
+
+      result
     end
-    # required field readers
 
-    attr_reader :unit_tags
+    def as_json(options = {})
+      result = {}
 
-    # optional field readers
+      resolved_action = self.action
+
+      result["unitCommand"] = (
+        if @unit_command.nil?
+          {}
+        else
+          @unit_command.as_json(options)
+        end
+      ) if resolved_action == :"unit_command"
+      result["cameraMove"] = (
+        if @camera_move.nil?
+          {}
+        else
+          @camera_move.as_json(options)
+        end
+      ) if resolved_action == :"camera_move"
+      result["toggleAutocast"] = (
+        if @toggle_autocast.nil?
+          {}
+        else
+          @toggle_autocast.as_json(options)
+        end
+      ) if resolved_action == :"toggle_autocast"
+
+      result
+    end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
+  end
+  class ActionRawUnitCommand
+    def self.decode(buff)
+      allocate.decode_from(buff.b, 0, buff.bytesize)
+    end
+
+    def self.encode(obj)
+      obj._encode("".b)
+    end
+    # required field readers
+
+    attr_reader :unit_tags
+
+    # optional field readers
 
     attr_reader :ability_id
 
@@ -16437,20 +17089,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
@@ -16506,15 +17177,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 =
@@ -16911,64 +17597,11 @@ module Api
 
           ## END PULL_UINT64
         end
-        if tag == 0x22
+        if tag == 0x20
           found = true
-          ## PULL_UINT64
-          value =
-            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
-
-          goal = index + value
+          ## DECODE REPEATED
           list = @unit_tags
           while true
-            break if index >= goal
             ## PULL_UINT64
             list << if (byte0 = buff.getbyte(index)) < 0x80
               index += 1
@@ -17019,60 +17652,71 @@ module Api
             end
 
             ## END PULL_UINT64
-          end
 
-          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
+            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
+                (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 PULL_UINT64
+
+            break unless tag == 0x20
+          end
+          ## END DECODE REPEATED
+
+          return self if index >= len
         end
         if tag == 0x28
           found = true
@@ -17141,10 +17785,10 @@ module Api
     end
     def _encode(buff)
       val = @ability_id
-      if val != 0
+      if has_ability_id?
         buff << 0x08
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -17155,6 +17799,7 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
@@ -17210,94 +17855,95 @@ module Api
       if val != 0
         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
 
       list = @unit_tags
       if list.size > 0
-        buff << 0x22
-
-        # 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 << 0x20
+
+            loop do
               byte = val & 0x7F
               val >>= 7
               byte |= 0x80 if val > 0
               buff << byte
+              break if val == 0
             end
           end
         end
+      end
 
-        # Calculate the submessage's size
-        submessage_size = buff.bytesize - current_len - 1
+      if has_queue_command?
+        val = @queue_command
+        buff << 0x28
 
-        # 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)
+        if val == true
+          buff << 1
+        elsif val == false
+          buff << 0
+        end
+      end
+      buff << @_unknown_fields if @_unknown_fields
+      buff
+    end
 
-        # If the sub message was bigger
-        if submessage_size > 0
-          current_len += 1
+    def to_h
+      result = {}
 
-          # 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
+      resolved_target = self.target
 
-          # Make space in the string with dummy bytes
-          buff.bytesplice(current_len, 0, "*********", 0, encoded_int_len)
+      result[:"ability_id"] = @ability_id
+      result[
+        :"target_world_space_pos"
+      ] = @target_world_space_pos.to_h if resolved_target ==
+        :"target_world_space_pos"
+      result[:"target_unit_tag"] = @target_unit_tag if resolved_target ==
+        :"target_unit_tag"
+      result[:"unit_tags"] = @unit_tags
+      result[:"queue_command"] = @queue_command
 
-          # 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
+    end
 
-      val = @queue_command
-      if val == true
-        buff << 0x28
+    def as_json(options = {})
+      result = {}
 
-        buff << 1
-      elsif val == false
-        # Default value, encode nothing
-      else
-        raise "bool values should be true or false"
-      end
+      resolved_target = self.target
 
-      buff
-    end
+      result["abilityId"] = @ability_id if !options[:compact] || has_ability_id?
+      result["targetWorldSpacePos"] = (
+        if @target_world_space_pos.nil?
+          {}
+        else
+          @target_world_space_pos.as_json(options)
+        end
+      ) if resolved_target == :"target_world_space_pos"
+      result["targetUnitTag"] = @target_unit_tag if resolved_target ==
+        :"target_unit_tag"
+      tmp_unit_tags = @unit_tags
+
+      result["unitTags"] = tmp_unit_tags if !options[:compact] ||
+        tmp_unit_tags.any?
+
+      result["queueCommand"] = @queue_command if !options[:compact] ||
+        has_queue_command?
 
-    def to_h
-      result = {}
-      send("target").tap { |f| result[f.to_sym] = send(f) if f }
-      result["ability_id".to_sym] = @ability_id
-      result["unit_tags".to_sym] = @unit_tags
-      result["queue_command".to_sym] = @queue_command
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class ActionRawCameraMove
     def self.decode(buff)
@@ -17404,20 +18050,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
@@ -17473,15 +18138,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 =
@@ -17702,15 +18382,36 @@ module Api
 
         buff
       end
-
+      buff << @_unknown_fields if @_unknown_fields
       buff
     end
 
     def to_h
       result = {}
-      result["center_world_space".to_sym] = @center_world_space.to_h
+
+      result[:"center_world_space"] = @center_world_space.to_h
+
+      result
+    end
+
+    def as_json(options = {})
+      result = {}
+
+      result["centerWorldSpace"] = (
+        if @center_world_space.nil?
+          {}
+        else
+          @center_world_space.as_json(options)
+        end
+      ) if !options[:compact] || has_center_world_space?
+
       result
     end
+
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
+    end
   end
   class ActionRawToggleAutocast
     def self.decode(buff)
@@ -17848,20 +18549,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
@@ -17917,15 +18637,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 =
@@ -18101,64 +18836,11 @@ module Api
 
           ## END PULL_UINT64
         end
-        if tag == 0x12
+        if tag == 0x10
           found = true
-          ## PULL_UINT64
-          value =
-            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
-
-          goal = index + value
+          ## DECODE REPEATED
           list = @unit_tags
           while true
-            break if index >= goal
             ## PULL_UINT64
             list << if (byte0 = buff.getbyte(index)) < 0x80
               index += 1
@@ -18209,60 +18891,71 @@ module Api
             end
 
             ## END PULL_UINT64
-          end
 
-          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
+            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
+                (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 PULL_UINT64
+
+            break unless tag == 0x10
+          end
+          ## END DECODE REPEATED
+
+          return self if index >= len
         end
 
         return self if index >= len
@@ -18270,10 +18963,10 @@ module Api
     end
     def _encode(buff)
       val = @ability_id
-      if val != 0
+      if has_ability_id?
         buff << 0x08
 
-        while val != 0
+        loop do
           byte = val & 0x7F
 
           val >>= 7
@@ -18284,75 +18977,55 @@ module Api
 
           byte |= 0x80 if val != 0
           buff << byte
+          break if val == 0
         end
       end
 
       list = @unit_tags
       if list.size > 0
-        buff << 0x12
-
-        # 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 << 0x10
+
+            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[:"ability_id"] = @ability_id
+      result[:"unit_tags"] = @unit_tags
 
-        # 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)
+      result["abilityId"] = @ability_id if !options[:compact] || has_ability_id?
+      tmp_unit_tags = @unit_tags
 
-          # 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["unitTags"] = tmp_unit_tags if !options[:compact] ||
+        tmp_unit_tags.any?
 
-      buff
+      result
     end
 
-    def to_h
-      result = {}
-      result["ability_id".to_sym] = @ability_id
-      result["unit_tags".to_sym] = @unit_tags
-      result
+    def to_json(as_json_options = {})
+      require "json"
+      JSON.dump(as_json(as_json_options))
     end
   end
 end