sc2ai 0.4.2 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (44) hide show
  1. checksums.yaml +4 -4
  2. data/data/sc2ai/protocol/data.proto +2 -2
  3. data/data/sc2ai/protocol/debug.proto +1 -1
  4. data/data/sc2ai/protocol/raw.proto +6 -6
  5. data/data/sc2ai/protocol/sc2api.proto +1 -1
  6. data/data/sc2ai/protocol/ui.proto +1 -1
  7. data/{lib/docker_build → docker_build}/Dockerfile.ruby +2 -2
  8. data/lib/sc2ai/cli/ladderzip.rb +1 -1
  9. data/lib/sc2ai/local_play/client.rb +1 -1
  10. data/lib/sc2ai/local_play/match.rb +1 -0
  11. data/lib/sc2ai/overrides/async/process/child.rb +2 -1
  12. data/lib/sc2ai/paths.rb +0 -1
  13. data/lib/sc2ai/player/debug.rb +3 -3
  14. data/lib/sc2ai/player.rb +9 -0
  15. data/lib/sc2ai/protocol/common_pb.rb +460 -105
  16. data/lib/sc2ai/protocol/data_pb.rb +833 -482
  17. data/lib/sc2ai/protocol/debug_pb.rb +1112 -401
  18. data/lib/sc2ai/protocol/error_pb.rb +430 -862
  19. data/lib/sc2ai/protocol/extensions/action.rb +1 -1
  20. data/lib/sc2ai/protocol/extensions/color.rb +1 -1
  21. data/lib/sc2ai/protocol/extensions/point.rb +1 -1
  22. data/lib/sc2ai/protocol/extensions/point_2_d.rb +1 -1
  23. data/lib/sc2ai/protocol/extensions/point_distance.rb +4 -4
  24. data/lib/sc2ai/protocol/extensions/position.rb +20 -0
  25. data/lib/sc2ai/protocol/extensions/power_source.rb +1 -1
  26. data/lib/sc2ai/protocol/extensions/unit.rb +1 -1
  27. data/lib/sc2ai/protocol/extensions/unit_type_data.rb +1 -1
  28. data/lib/sc2ai/protocol/query_pb.rb +558 -88
  29. data/lib/sc2ai/protocol/raw_pb.rb +1829 -1156
  30. data/lib/sc2ai/protocol/sc2api_pb.rb +5233 -1463
  31. data/lib/sc2ai/protocol/score_pb.rb +444 -103
  32. data/lib/sc2ai/protocol/spatial_pb.rb +935 -145
  33. data/lib/sc2ai/protocol/ui_pb.rb +1432 -435
  34. data/lib/sc2ai/version.rb +1 -1
  35. data/lib/templates/new/api/data.proto +2 -2
  36. data/lib/templates/new/api/debug.proto +1 -1
  37. data/lib/templates/new/api/raw.proto +6 -6
  38. data/lib/templates/new/api/sc2api.proto +1 -1
  39. data/lib/templates/new/api/ui.proto +1 -1
  40. data/lib/templates/new/run_example_match.rb.tt +1 -1
  41. data/sig/sc2ai.rbs +1361 -23
  42. metadata +7 -7
  43. /data/{lib/docker_build → docker_build}/docker-compose-base-image.yml +0 -0
  44. /data/{lib/docker_build → docker_build}/docker-compose-ladderzip.yml +0 -0
@@ -18,59 +18,33 @@ module Api
18
18
  SUMMONED = 11
19
19
 
20
20
  def self.lookup(val)
21
- if val == 0
22
- :ENUM_ATTRIBUTE_UNSET
23
- elsif val == 1
24
- :LIGHT
25
- elsif val == 2
26
- :ARMORED
27
- elsif val == 3
28
- :BIOLOGICAL
29
- elsif val == 4
30
- :MECHANICAL
31
- elsif val == 5
32
- :ROBOTIC
33
- elsif val == 6
34
- :PSIONIC
35
- elsif val == 7
36
- :MASSIVE
37
- elsif val == 8
38
- :STRUCTURE
39
- elsif val == 9
40
- :HOVER
41
- elsif val == 10
42
- :HEROIC
43
- elsif val == 11
44
- :SUMMONED
45
- end
21
+ return :ENUM_ATTRIBUTE_UNSET if val == 0
22
+ return :LIGHT if val == 1
23
+ return :ARMORED if val == 2
24
+ return :BIOLOGICAL if val == 3
25
+ return :MECHANICAL if val == 4
26
+ return :ROBOTIC if val == 5
27
+ return :PSIONIC if val == 6
28
+ return :MASSIVE if val == 7
29
+ return :STRUCTURE if val == 8
30
+ return :HOVER if val == 9
31
+ return :HEROIC if val == 10
32
+ return :SUMMONED if val == 11
46
33
  end
47
34
 
48
35
  def self.resolve(val)
49
- if val == :ENUM_ATTRIBUTE_UNSET
50
- 0
51
- elsif val == :LIGHT
52
- 1
53
- elsif val == :ARMORED
54
- 2
55
- elsif val == :BIOLOGICAL
56
- 3
57
- elsif val == :MECHANICAL
58
- 4
59
- elsif val == :ROBOTIC
60
- 5
61
- elsif val == :PSIONIC
62
- 6
63
- elsif val == :MASSIVE
64
- 7
65
- elsif val == :STRUCTURE
66
- 8
67
- elsif val == :HOVER
68
- 9
69
- elsif val == :HEROIC
70
- 10
71
- elsif val == :SUMMONED
72
- 11
73
- end
36
+ return 0 if val == :ENUM_ATTRIBUTE_UNSET
37
+ return 1 if val == :LIGHT
38
+ return 2 if val == :ARMORED
39
+ return 3 if val == :BIOLOGICAL
40
+ return 4 if val == :MECHANICAL
41
+ return 5 if val == :ROBOTIC
42
+ return 6 if val == :PSIONIC
43
+ return 7 if val == :MASSIVE
44
+ return 8 if val == :STRUCTURE
45
+ return 9 if val == :HOVER
46
+ return 10 if val == :HEROIC
47
+ return 11 if val == :SUMMONED
74
48
  end
75
49
  end
76
50
 
@@ -91,35 +65,21 @@ module Api
91
65
  POINT_OR_NONE = 5
92
66
 
93
67
  def self.lookup(val)
94
- if val == 0
95
- :ENUM_TARGET_UNSET
96
- elsif val == 1
97
- :NONE
98
- elsif val == 2
99
- :POINT
100
- elsif val == 3
101
- :UNIT
102
- elsif val == 4
103
- :POINT_OR_UNIT
104
- elsif val == 5
105
- :POINT_OR_NONE
106
- end
68
+ return :ENUM_TARGET_UNSET if val == 0
69
+ return :NONE if val == 1
70
+ return :POINT if val == 2
71
+ return :UNIT if val == 3
72
+ return :POINT_OR_UNIT if val == 4
73
+ return :POINT_OR_NONE if val == 5
107
74
  end
108
75
 
109
76
  def self.resolve(val)
110
- if val == :ENUM_TARGET_UNSET
111
- 0
112
- elsif val == :NONE
113
- 1
114
- elsif val == :POINT
115
- 2
116
- elsif val == :UNIT
117
- 3
118
- elsif val == :POINT_OR_UNIT
119
- 4
120
- elsif val == :POINT_OR_NONE
121
- 5
122
- end
77
+ return 0 if val == :ENUM_TARGET_UNSET
78
+ return 1 if val == :NONE
79
+ return 2 if val == :POINT
80
+ return 3 if val == :UNIT
81
+ return 4 if val == :POINT_OR_UNIT
82
+ return 5 if val == :POINT_OR_NONE
123
83
  end
124
84
  end
125
85
  # required field readers
@@ -161,6 +121,7 @@ module Api
161
121
  # enum writers
162
122
  def target=(v)
163
123
  @target = Api::AbilityData::Target.resolve(v) || v
124
+ @_bitmask |= 0x0000000000000100
164
125
  end
165
126
 
166
127
  # BEGIN writers for optional fields
@@ -425,6 +386,10 @@ module Api
425
386
  (@_bitmask & 0x0000000000000080) == 0x0000000000000080
426
387
  end
427
388
 
389
+ def has_target?
390
+ (@_bitmask & 0x0000000000000100) == 0x0000000000000100
391
+ end
392
+
428
393
  def has_allow_minimap?
429
394
  (@_bitmask & 0x0000000000000200) == 0x0000000000000200
430
395
  end
@@ -527,20 +492,39 @@ module Api
527
492
  # unexpected, so discard it and continue.
528
493
  if !found
529
494
  wire_type = tag & 0x7
495
+
496
+ unknown_bytes = +"".b
497
+ val = tag
498
+ loop do
499
+ byte = val & 0x7F
500
+
501
+ val >>= 7
502
+ # This drops the top bits,
503
+ # Otherwise, with a signed right shift,
504
+ # we get infinity one bits at the top
505
+ val &= (1 << 57) - 1
506
+
507
+ byte |= 0x80 if val != 0
508
+ unknown_bytes << byte
509
+ break if val == 0
510
+ end
511
+
530
512
  case wire_type
531
513
  when 0
532
514
  i = 0
533
515
  while true
534
516
  newbyte = buff.getbyte(index)
535
517
  index += 1
536
- break if newbyte.nil? || newbyte < 0x80
518
+ break if newbyte.nil?
519
+ unknown_bytes << newbyte
520
+ break if newbyte < 0x80
537
521
  i += 1
538
522
  break if i > 9
539
523
  end
540
524
  when 1
525
+ unknown_bytes << buff.byteslice(index, 8)
541
526
  index += 8
542
527
  when 2
543
- ## PULL_BYTES
544
528
  value =
545
529
  if (byte0 = buff.getbyte(index)) < 0x80
546
530
  index += 1
@@ -596,15 +580,30 @@ module Api
596
580
  raise "integer decoding error"
597
581
  end
598
582
 
599
- buff.byteslice(index, value)
600
- index += value
583
+ val = value
584
+ loop do
585
+ byte = val & 0x7F
586
+
587
+ val >>= 7
588
+ # This drops the top bits,
589
+ # Otherwise, with a signed right shift,
590
+ # we get infinity one bits at the top
591
+ val &= (1 << 57) - 1
601
592
 
602
- ## END PULL_BYTES
593
+ byte |= 0x80 if val != 0
594
+ unknown_bytes << byte
595
+ break if val == 0
596
+ end
597
+
598
+ unknown_bytes << buff.byteslice(index, value)
599
+ index += value
603
600
  when 5
601
+ unknown_bytes << buff.byteslice(index, 4)
604
602
  index += 4
605
603
  else
606
604
  raise "unknown wire type #{wire_type}"
607
605
  end
606
+ (@_unknown_fields ||= +"".b) << unknown_bytes
608
607
  return self if index >= len
609
608
  ## PULL_UINT64
610
609
  tag =
@@ -1978,109 +1977,116 @@ module Api
1978
1977
  end
1979
1978
  def _encode(buff)
1980
1979
  val = @ability_id
1981
- if val != 0
1980
+ if has_ability_id?
1982
1981
  buff << 0x08
1983
1982
 
1984
- while val != 0
1983
+ loop do
1985
1984
  byte = val & 0x7F
1986
1985
  val >>= 7
1987
1986
  byte |= 0x80 if val > 0
1988
1987
  buff << byte
1988
+ break if val == 0
1989
1989
  end
1990
1990
  end
1991
1991
 
1992
1992
  val = @link_name
1993
- if ((len = val.bytesize) > 0)
1993
+ if (len = val.bytesize) > 0 || has_link_name?
1994
1994
  buff << 0x12
1995
- while len != 0
1995
+ loop do
1996
1996
  byte = len & 0x7F
1997
1997
  len >>= 7
1998
1998
  byte |= 0x80 if len > 0
1999
1999
  buff << byte
2000
+ break if len == 0
2000
2001
  end
2001
2002
 
2002
2003
  buff << (val.ascii_only? ? val : val.b)
2003
2004
  end
2004
2005
 
2005
2006
  val = @link_index
2006
- if val != 0
2007
+ if has_link_index?
2007
2008
  buff << 0x18
2008
2009
 
2009
- while val != 0
2010
+ loop do
2010
2011
  byte = val & 0x7F
2011
2012
  val >>= 7
2012
2013
  byte |= 0x80 if val > 0
2013
2014
  buff << byte
2015
+ break if val == 0
2014
2016
  end
2015
2017
  end
2016
2018
 
2017
2019
  val = @button_name
2018
- if ((len = val.bytesize) > 0)
2020
+ if (len = val.bytesize) > 0 || has_button_name?
2019
2021
  buff << 0x22
2020
- while len != 0
2022
+ loop do
2021
2023
  byte = len & 0x7F
2022
2024
  len >>= 7
2023
2025
  byte |= 0x80 if len > 0
2024
2026
  buff << byte
2027
+ break if len == 0
2025
2028
  end
2026
2029
 
2027
2030
  buff << (val.ascii_only? ? val : val.b)
2028
2031
  end
2029
2032
 
2030
2033
  val = @friendly_name
2031
- if ((len = val.bytesize) > 0)
2034
+ if (len = val.bytesize) > 0 || has_friendly_name?
2032
2035
  buff << 0x2a
2033
- while len != 0
2036
+ loop do
2034
2037
  byte = len & 0x7F
2035
2038
  len >>= 7
2036
2039
  byte |= 0x80 if len > 0
2037
2040
  buff << byte
2041
+ break if len == 0
2038
2042
  end
2039
2043
 
2040
2044
  buff << (val.ascii_only? ? val : val.b)
2041
2045
  end
2042
2046
 
2043
2047
  val = @hotkey
2044
- if ((len = val.bytesize) > 0)
2048
+ if (len = val.bytesize) > 0 || has_hotkey?
2045
2049
  buff << 0x32
2046
- while len != 0
2050
+ loop do
2047
2051
  byte = len & 0x7F
2048
2052
  len >>= 7
2049
2053
  byte |= 0x80 if len > 0
2050
2054
  buff << byte
2055
+ break if len == 0
2051
2056
  end
2052
2057
 
2053
2058
  buff << (val.ascii_only? ? val : val.b)
2054
2059
  end
2055
2060
 
2056
2061
  val = @remaps_to_ability_id
2057
- if val != 0
2062
+ if has_remaps_to_ability_id?
2058
2063
  buff << 0x38
2059
2064
 
2060
- while val != 0
2065
+ loop do
2061
2066
  byte = val & 0x7F
2062
2067
  val >>= 7
2063
2068
  byte |= 0x80 if val > 0
2064
2069
  buff << byte
2070
+ break if val == 0
2065
2071
  end
2066
2072
  end
2067
2073
 
2068
- val = @available
2069
- if val == true
2074
+ if has_available?
2075
+ val = @available
2070
2076
  buff << 0x40
2071
2077
 
2072
- buff << 1
2073
- elsif val == false
2074
- # Default value, encode nothing
2075
- else
2076
- raise "bool values should be true or false"
2078
+ if val == true
2079
+ buff << 1
2080
+ elsif val == false
2081
+ buff << 0
2082
+ end
2077
2083
  end
2078
2084
 
2079
2085
  val = @target
2080
- if val != 0
2086
+ if has_target?
2081
2087
  buff << 0x48
2082
2088
 
2083
- while val != 0
2089
+ loop do
2084
2090
  byte = val & 0x7F
2085
2091
 
2086
2092
  val >>= 7
@@ -2091,89 +2097,129 @@ module Api
2091
2097
 
2092
2098
  byte |= 0x80 if val != 0
2093
2099
  buff << byte
2100
+ break if val == 0
2094
2101
  end
2095
2102
  end
2096
2103
 
2097
- val = @allow_minimap
2098
- if val == true
2104
+ if has_allow_minimap?
2105
+ val = @allow_minimap
2099
2106
  buff << 0x50
2100
2107
 
2101
- buff << 1
2102
- elsif val == false
2103
- # Default value, encode nothing
2104
- else
2105
- raise "bool values should be true or false"
2108
+ if val == true
2109
+ buff << 1
2110
+ elsif val == false
2111
+ buff << 0
2112
+ end
2106
2113
  end
2107
2114
 
2108
- val = @allow_autocast
2109
- if val == true
2115
+ if has_allow_autocast?
2116
+ val = @allow_autocast
2110
2117
  buff << 0x58
2111
2118
 
2112
- buff << 1
2113
- elsif val == false
2114
- # Default value, encode nothing
2115
- else
2116
- raise "bool values should be true or false"
2119
+ if val == true
2120
+ buff << 1
2121
+ elsif val == false
2122
+ buff << 0
2123
+ end
2117
2124
  end
2118
2125
 
2119
- val = @is_building
2120
- if val == true
2126
+ if has_is_building?
2127
+ val = @is_building
2121
2128
  buff << 0x60
2122
2129
 
2123
- buff << 1
2124
- elsif val == false
2125
- # Default value, encode nothing
2126
- else
2127
- raise "bool values should be true or false"
2130
+ if val == true
2131
+ buff << 1
2132
+ elsif val == false
2133
+ buff << 0
2134
+ end
2128
2135
  end
2129
2136
 
2130
2137
  val = @footprint_radius
2131
- if val != 0
2138
+ if has_footprint_radius?
2132
2139
  buff << 0x6d
2133
2140
 
2134
2141
  [val].pack("e", buffer: buff)
2135
2142
  end
2136
2143
 
2137
- val = @is_instant_placement
2138
- if val == true
2144
+ if has_is_instant_placement?
2145
+ val = @is_instant_placement
2139
2146
  buff << 0x70
2140
2147
 
2141
- buff << 1
2142
- elsif val == false
2143
- # Default value, encode nothing
2144
- else
2145
- raise "bool values should be true or false"
2148
+ if val == true
2149
+ buff << 1
2150
+ elsif val == false
2151
+ buff << 0
2152
+ end
2146
2153
  end
2147
2154
 
2148
2155
  val = @cast_range
2149
- if val != 0
2156
+ if has_cast_range?
2150
2157
  buff << 0x7d
2151
2158
 
2152
2159
  [val].pack("e", buffer: buff)
2153
2160
  end
2154
-
2161
+ buff << @_unknown_fields if @_unknown_fields
2155
2162
  buff
2156
2163
  end
2157
2164
 
2158
2165
  def to_h
2159
2166
  result = {}
2160
- result["ability_id".to_sym] = @ability_id
2161
- result["link_name".to_sym] = @link_name
2162
- result["link_index".to_sym] = @link_index
2163
- result["button_name".to_sym] = @button_name
2164
- result["friendly_name".to_sym] = @friendly_name
2165
- result["hotkey".to_sym] = @hotkey
2166
- result["remaps_to_ability_id".to_sym] = @remaps_to_ability_id
2167
- result["available".to_sym] = @available
2168
- result["target".to_sym] = @target
2169
- result["allow_minimap".to_sym] = @allow_minimap
2170
- result["allow_autocast".to_sym] = @allow_autocast
2171
- result["is_building".to_sym] = @is_building
2172
- result["footprint_radius".to_sym] = @footprint_radius
2173
- result["is_instant_placement".to_sym] = @is_instant_placement
2174
- result["cast_range".to_sym] = @cast_range
2167
+
2168
+ result[:"ability_id"] = @ability_id
2169
+ result[:"link_name"] = @link_name
2170
+ result[:"link_index"] = @link_index
2171
+ result[:"button_name"] = @button_name
2172
+ result[:"friendly_name"] = @friendly_name
2173
+ result[:"hotkey"] = @hotkey
2174
+ result[:"remaps_to_ability_id"] = @remaps_to_ability_id
2175
+ result[:"available"] = @available
2176
+ result[:"target"] = @target
2177
+ result[:"allow_minimap"] = @allow_minimap
2178
+ result[:"allow_autocast"] = @allow_autocast
2179
+ result[:"is_building"] = @is_building
2180
+ result[:"footprint_radius"] = @footprint_radius
2181
+ result[:"is_instant_placement"] = @is_instant_placement
2182
+ result[:"cast_range"] = @cast_range
2183
+
2184
+ result
2185
+ end
2186
+
2187
+ def as_json(options = {})
2188
+ result = {}
2189
+
2190
+ result["abilityId"] = @ability_id if !options[:compact] || has_ability_id?
2191
+ result["linkName"] = @link_name if !options[:compact] || has_link_name?
2192
+ result["linkIndex"] = @link_index if !options[:compact] || has_link_index?
2193
+ result["buttonName"] = @button_name if !options[:compact] ||
2194
+ has_button_name?
2195
+ result["friendlyName"] = @friendly_name if !options[:compact] ||
2196
+ has_friendly_name?
2197
+ result["hotkey"] = @hotkey if !options[:compact] || has_hotkey?
2198
+ result["remapsToAbilityId"] = @remaps_to_ability_id if !options[
2199
+ :compact
2200
+ ] || has_remaps_to_ability_id?
2201
+ result["available"] = @available if !options[:compact] || has_available?
2202
+ result["target"] = @target if !options[:compact] || has_target?
2203
+ result["allowMinimap"] = @allow_minimap if !options[:compact] ||
2204
+ has_allow_minimap?
2205
+ result["allowAutocast"] = @allow_autocast if !options[:compact] ||
2206
+ has_allow_autocast?
2207
+ result["isBuilding"] = @is_building if !options[:compact] ||
2208
+ has_is_building?
2209
+ result["footprintRadius"] = @footprint_radius if !options[:compact] ||
2210
+ has_footprint_radius?
2211
+ result["isInstantPlacement"] = @is_instant_placement if !options[
2212
+ :compact
2213
+ ] || has_is_instant_placement?
2214
+ result["castRange"] = @cast_range if !options[:compact] || has_cast_range?
2215
+
2175
2216
  result
2176
2217
  end
2218
+
2219
+ def to_json(as_json_options = {})
2220
+ require "json"
2221
+ JSON.dump(as_json(as_json_options))
2222
+ end
2177
2223
  end
2178
2224
  class DamageBonus
2179
2225
  def self.decode(buff)
@@ -2196,6 +2242,7 @@ module Api
2196
2242
  # enum writers
2197
2243
  def attribute=(v)
2198
2244
  @attribute = Api::Attribute.resolve(v) || v
2245
+ @_bitmask |= 0x0000000000000001
2199
2246
  end
2200
2247
 
2201
2248
  # BEGIN writers for optional fields
@@ -2228,6 +2275,10 @@ module Api
2228
2275
  self.class.encode(self)
2229
2276
  end
2230
2277
 
2278
+ def has_attribute?
2279
+ (@_bitmask & 0x0000000000000001) == 0x0000000000000001
2280
+ end
2281
+
2231
2282
  def has_bonus?
2232
2283
  (@_bitmask & 0x0000000000000002) == 0x0000000000000002
2233
2284
  end
@@ -2297,20 +2348,39 @@ module Api
2297
2348
  # unexpected, so discard it and continue.
2298
2349
  if !found
2299
2350
  wire_type = tag & 0x7
2351
+
2352
+ unknown_bytes = +"".b
2353
+ val = tag
2354
+ loop do
2355
+ byte = val & 0x7F
2356
+
2357
+ val >>= 7
2358
+ # This drops the top bits,
2359
+ # Otherwise, with a signed right shift,
2360
+ # we get infinity one bits at the top
2361
+ val &= (1 << 57) - 1
2362
+
2363
+ byte |= 0x80 if val != 0
2364
+ unknown_bytes << byte
2365
+ break if val == 0
2366
+ end
2367
+
2300
2368
  case wire_type
2301
2369
  when 0
2302
2370
  i = 0
2303
2371
  while true
2304
2372
  newbyte = buff.getbyte(index)
2305
2373
  index += 1
2306
- break if newbyte.nil? || newbyte < 0x80
2374
+ break if newbyte.nil?
2375
+ unknown_bytes << newbyte
2376
+ break if newbyte < 0x80
2307
2377
  i += 1
2308
2378
  break if i > 9
2309
2379
  end
2310
2380
  when 1
2381
+ unknown_bytes << buff.byteslice(index, 8)
2311
2382
  index += 8
2312
2383
  when 2
2313
- ## PULL_BYTES
2314
2384
  value =
2315
2385
  if (byte0 = buff.getbyte(index)) < 0x80
2316
2386
  index += 1
@@ -2366,15 +2436,30 @@ module Api
2366
2436
  raise "integer decoding error"
2367
2437
  end
2368
2438
 
2369
- buff.byteslice(index, value)
2370
- index += value
2439
+ val = value
2440
+ loop do
2441
+ byte = val & 0x7F
2442
+
2443
+ val >>= 7
2444
+ # This drops the top bits,
2445
+ # Otherwise, with a signed right shift,
2446
+ # we get infinity one bits at the top
2447
+ val &= (1 << 57) - 1
2371
2448
 
2372
- ## END PULL_BYTES
2449
+ byte |= 0x80 if val != 0
2450
+ unknown_bytes << byte
2451
+ break if val == 0
2452
+ end
2453
+
2454
+ unknown_bytes << buff.byteslice(index, value)
2455
+ index += value
2373
2456
  when 5
2457
+ unknown_bytes << buff.byteslice(index, 4)
2374
2458
  index += 4
2375
2459
  else
2376
2460
  raise "unknown wire type #{wire_type}"
2377
2461
  end
2462
+ (@_unknown_fields ||= +"".b) << unknown_bytes
2378
2463
  return self if index >= len
2379
2464
  ## PULL_UINT64
2380
2465
  tag =
@@ -2614,10 +2699,10 @@ module Api
2614
2699
  end
2615
2700
  def _encode(buff)
2616
2701
  val = @attribute
2617
- if val != 0
2702
+ if has_attribute?
2618
2703
  buff << 0x08
2619
2704
 
2620
- while val != 0
2705
+ loop do
2621
2706
  byte = val & 0x7F
2622
2707
 
2623
2708
  val >>= 7
@@ -2628,25 +2713,42 @@ module Api
2628
2713
 
2629
2714
  byte |= 0x80 if val != 0
2630
2715
  buff << byte
2716
+ break if val == 0
2631
2717
  end
2632
2718
  end
2633
2719
 
2634
2720
  val = @bonus
2635
- if val != 0
2721
+ if has_bonus?
2636
2722
  buff << 0x15
2637
2723
 
2638
2724
  [val].pack("e", buffer: buff)
2639
2725
  end
2640
-
2726
+ buff << @_unknown_fields if @_unknown_fields
2641
2727
  buff
2642
2728
  end
2643
2729
 
2644
2730
  def to_h
2645
2731
  result = {}
2646
- result["attribute".to_sym] = @attribute
2647
- result["bonus".to_sym] = @bonus
2732
+
2733
+ result[:"attribute"] = @attribute
2734
+ result[:"bonus"] = @bonus
2735
+
2648
2736
  result
2649
2737
  end
2738
+
2739
+ def as_json(options = {})
2740
+ result = {}
2741
+
2742
+ result["attribute"] = @attribute if !options[:compact] || has_attribute?
2743
+ result["bonus"] = @bonus if !options[:compact] || has_bonus?
2744
+
2745
+ result
2746
+ end
2747
+
2748
+ def to_json(as_json_options = {})
2749
+ require "json"
2750
+ JSON.dump(as_json(as_json_options))
2751
+ end
2650
2752
  end
2651
2753
  class Weapon
2652
2754
  def self.decode(buff)
@@ -2663,27 +2765,17 @@ module Api
2663
2765
  ANY = 3
2664
2766
 
2665
2767
  def self.lookup(val)
2666
- if val == 0
2667
- :ENUM_TARGET_TYPE_UNSET
2668
- elsif val == 1
2669
- :GROUND
2670
- elsif val == 2
2671
- :AIR
2672
- elsif val == 3
2673
- :ANY
2674
- end
2768
+ return :ENUM_TARGET_TYPE_UNSET if val == 0
2769
+ return :GROUND if val == 1
2770
+ return :AIR if val == 2
2771
+ return :ANY if val == 3
2675
2772
  end
2676
2773
 
2677
2774
  def self.resolve(val)
2678
- if val == :ENUM_TARGET_TYPE_UNSET
2679
- 0
2680
- elsif val == :GROUND
2681
- 1
2682
- elsif val == :AIR
2683
- 2
2684
- elsif val == :ANY
2685
- 3
2686
- end
2775
+ return 0 if val == :ENUM_TARGET_TYPE_UNSET
2776
+ return 1 if val == :GROUND
2777
+ return 2 if val == :AIR
2778
+ return 3 if val == :ANY
2687
2779
  end
2688
2780
  end
2689
2781
  # required field readers
@@ -2711,6 +2803,7 @@ module Api
2711
2803
  # enum writers
2712
2804
  def type=(v)
2713
2805
  @type = Api::Weapon::TargetType.resolve(v) || v
2806
+ @_bitmask |= 0x0000000000000001
2714
2807
  end
2715
2808
 
2716
2809
  # BEGIN writers for optional fields
@@ -2797,6 +2890,10 @@ module Api
2797
2890
  self.class.encode(self)
2798
2891
  end
2799
2892
 
2893
+ def has_type?
2894
+ (@_bitmask & 0x0000000000000001) == 0x0000000000000001
2895
+ end
2896
+
2800
2897
  def has_damage?
2801
2898
  (@_bitmask & 0x0000000000000002) == 0x0000000000000002
2802
2899
  end
@@ -2882,20 +2979,39 @@ module Api
2882
2979
  # unexpected, so discard it and continue.
2883
2980
  if !found
2884
2981
  wire_type = tag & 0x7
2982
+
2983
+ unknown_bytes = +"".b
2984
+ val = tag
2985
+ loop do
2986
+ byte = val & 0x7F
2987
+
2988
+ val >>= 7
2989
+ # This drops the top bits,
2990
+ # Otherwise, with a signed right shift,
2991
+ # we get infinity one bits at the top
2992
+ val &= (1 << 57) - 1
2993
+
2994
+ byte |= 0x80 if val != 0
2995
+ unknown_bytes << byte
2996
+ break if val == 0
2997
+ end
2998
+
2885
2999
  case wire_type
2886
3000
  when 0
2887
3001
  i = 0
2888
3002
  while true
2889
3003
  newbyte = buff.getbyte(index)
2890
3004
  index += 1
2891
- break if newbyte.nil? || newbyte < 0x80
3005
+ break if newbyte.nil?
3006
+ unknown_bytes << newbyte
3007
+ break if newbyte < 0x80
2892
3008
  i += 1
2893
3009
  break if i > 9
2894
3010
  end
2895
3011
  when 1
3012
+ unknown_bytes << buff.byteslice(index, 8)
2896
3013
  index += 8
2897
3014
  when 2
2898
- ## PULL_BYTES
2899
3015
  value =
2900
3016
  if (byte0 = buff.getbyte(index)) < 0x80
2901
3017
  index += 1
@@ -2951,15 +3067,30 @@ module Api
2951
3067
  raise "integer decoding error"
2952
3068
  end
2953
3069
 
2954
- buff.byteslice(index, value)
2955
- index += value
3070
+ val = value
3071
+ loop do
3072
+ byte = val & 0x7F
3073
+
3074
+ val >>= 7
3075
+ # This drops the top bits,
3076
+ # Otherwise, with a signed right shift,
3077
+ # we get infinity one bits at the top
3078
+ val &= (1 << 57) - 1
3079
+
3080
+ byte |= 0x80 if val != 0
3081
+ unknown_bytes << byte
3082
+ break if val == 0
3083
+ end
2956
3084
 
2957
- ## END PULL_BYTES
3085
+ unknown_bytes << buff.byteslice(index, value)
3086
+ index += value
2958
3087
  when 5
3088
+ unknown_bytes << buff.byteslice(index, 4)
2959
3089
  index += 4
2960
3090
  else
2961
3091
  raise "unknown wire type #{wire_type}"
2962
3092
  end
3093
+ (@_unknown_fields ||= +"".b) << unknown_bytes
2963
3094
  return self if index >= len
2964
3095
  ## PULL_UINT64
2965
3096
  tag =
@@ -3559,10 +3690,10 @@ module Api
3559
3690
  end
3560
3691
  def _encode(buff)
3561
3692
  val = @type
3562
- if val != 0
3693
+ if has_type?
3563
3694
  buff << 0x08
3564
3695
 
3565
- while val != 0
3696
+ loop do
3566
3697
  byte = val & 0x7F
3567
3698
 
3568
3699
  val >>= 7
@@ -3573,11 +3704,12 @@ module Api
3573
3704
 
3574
3705
  byte |= 0x80 if val != 0
3575
3706
  buff << byte
3707
+ break if val == 0
3576
3708
  end
3577
3709
  end
3578
3710
 
3579
3711
  val = @damage
3580
- if val != 0
3712
+ if has_damage?
3581
3713
  buff << 0x15
3582
3714
 
3583
3715
  [val].pack("e", buffer: buff)
@@ -3637,44 +3769,69 @@ module Api
3637
3769
  end
3638
3770
 
3639
3771
  val = @attacks
3640
- if val != 0
3772
+ if has_attacks?
3641
3773
  buff << 0x20
3642
3774
 
3643
- while val != 0
3775
+ loop do
3644
3776
  byte = val & 0x7F
3645
3777
  val >>= 7
3646
3778
  byte |= 0x80 if val > 0
3647
3779
  buff << byte
3780
+ break if val == 0
3648
3781
  end
3649
3782
  end
3650
3783
 
3651
3784
  val = @range
3652
- if val != 0
3785
+ if has_range?
3653
3786
  buff << 0x2d
3654
3787
 
3655
3788
  [val].pack("e", buffer: buff)
3656
3789
  end
3657
3790
 
3658
3791
  val = @speed
3659
- if val != 0
3792
+ if has_speed?
3660
3793
  buff << 0x35
3661
3794
 
3662
3795
  [val].pack("e", buffer: buff)
3663
3796
  end
3664
-
3797
+ buff << @_unknown_fields if @_unknown_fields
3665
3798
  buff
3666
3799
  end
3667
3800
 
3668
3801
  def to_h
3669
3802
  result = {}
3670
- result["type".to_sym] = @type
3671
- result["damage".to_sym] = @damage
3672
- result["damage_bonus".to_sym] = @damage_bonus
3673
- result["attacks".to_sym] = @attacks
3674
- result["range".to_sym] = @range
3675
- result["speed".to_sym] = @speed
3803
+
3804
+ result[:"type"] = @type
3805
+ result[:"damage"] = @damage
3806
+ result[:"damage_bonus"] = @damage_bonus.map(&:to_h)
3807
+ result[:"attacks"] = @attacks
3808
+ result[:"range"] = @range
3809
+ result[:"speed"] = @speed
3810
+
3676
3811
  result
3677
3812
  end
3813
+
3814
+ def as_json(options = {})
3815
+ result = {}
3816
+
3817
+ result["type"] = @type if !options[:compact] || has_type?
3818
+ result["damage"] = @damage if !options[:compact] || has_damage?
3819
+ tmp_damage_bonus = @damage_bonus.map { |v| v.as_json(options) }
3820
+
3821
+ result["damageBonus"] = tmp_damage_bonus if !options[:compact] ||
3822
+ tmp_damage_bonus.any?
3823
+
3824
+ result["attacks"] = @attacks if !options[:compact] || has_attacks?
3825
+ result["range"] = @range if !options[:compact] || has_range?
3826
+ result["speed"] = @speed if !options[:compact] || has_speed?
3827
+
3828
+ result
3829
+ end
3830
+
3831
+ def to_json(as_json_options = {})
3832
+ require "json"
3833
+ JSON.dump(as_json(as_json_options))
3834
+ end
3678
3835
  end
3679
3836
  class UnitTypeData
3680
3837
  def self.decode(buff)
@@ -3753,6 +3910,7 @@ module Api
3753
3910
  # enum writers
3754
3911
  def race=(v)
3755
3912
  @race = Api::Race.resolve(v) || v
3913
+ @_bitmask |= 0x0000000000000200
3756
3914
  end
3757
3915
  def attributes=(v)
3758
3916
  @attributes = Api::Attribute.resolve(v) || v
@@ -4125,6 +4283,10 @@ module Api
4125
4283
  (@_bitmask & 0x0000000000000100) == 0x0000000000000100
4126
4284
  end
4127
4285
 
4286
+ def has_race?
4287
+ (@_bitmask & 0x0000000000000200) == 0x0000000000000200
4288
+ end
4289
+
4128
4290
  def has_build_time?
4129
4291
  (@_bitmask & 0x0000000000000400) == 0x0000000000000400
4130
4292
  end
@@ -4246,20 +4408,39 @@ module Api
4246
4408
  # unexpected, so discard it and continue.
4247
4409
  if !found
4248
4410
  wire_type = tag & 0x7
4411
+
4412
+ unknown_bytes = +"".b
4413
+ val = tag
4414
+ loop do
4415
+ byte = val & 0x7F
4416
+
4417
+ val >>= 7
4418
+ # This drops the top bits,
4419
+ # Otherwise, with a signed right shift,
4420
+ # we get infinity one bits at the top
4421
+ val &= (1 << 57) - 1
4422
+
4423
+ byte |= 0x80 if val != 0
4424
+ unknown_bytes << byte
4425
+ break if val == 0
4426
+ end
4427
+
4249
4428
  case wire_type
4250
4429
  when 0
4251
4430
  i = 0
4252
4431
  while true
4253
4432
  newbyte = buff.getbyte(index)
4254
4433
  index += 1
4255
- break if newbyte.nil? || newbyte < 0x80
4434
+ break if newbyte.nil?
4435
+ unknown_bytes << newbyte
4436
+ break if newbyte < 0x80
4256
4437
  i += 1
4257
4438
  break if i > 9
4258
4439
  end
4259
4440
  when 1
4441
+ unknown_bytes << buff.byteslice(index, 8)
4260
4442
  index += 8
4261
4443
  when 2
4262
- ## PULL_BYTES
4263
4444
  value =
4264
4445
  if (byte0 = buff.getbyte(index)) < 0x80
4265
4446
  index += 1
@@ -4315,15 +4496,30 @@ module Api
4315
4496
  raise "integer decoding error"
4316
4497
  end
4317
4498
 
4318
- buff.byteslice(index, value)
4319
- index += value
4499
+ val = value
4500
+ loop do
4501
+ byte = val & 0x7F
4320
4502
 
4321
- ## END PULL_BYTES
4503
+ val >>= 7
4504
+ # This drops the top bits,
4505
+ # Otherwise, with a signed right shift,
4506
+ # we get infinity one bits at the top
4507
+ val &= (1 << 57) - 1
4508
+
4509
+ byte |= 0x80 if val != 0
4510
+ unknown_bytes << byte
4511
+ break if val == 0
4512
+ end
4513
+
4514
+ unknown_bytes << buff.byteslice(index, value)
4515
+ index += value
4322
4516
  when 5
4517
+ unknown_bytes << buff.byteslice(index, 4)
4323
4518
  index += 4
4324
4519
  else
4325
4520
  raise "unknown wire type #{wire_type}"
4326
4521
  end
4522
+ (@_unknown_fields ||= +"".b) << unknown_bytes
4327
4523
  return self if index >= len
4328
4524
  ## PULL_UINT64
4329
4525
  tag =
@@ -5565,64 +5761,11 @@ module Api
5565
5761
 
5566
5762
  ## END PULL_UINT64
5567
5763
  end
5568
- if tag == 0xaa
5764
+ if tag == 0xa8
5569
5765
  found = true
5570
- ## PULL_UINT64
5571
- value =
5572
- if (byte0 = buff.getbyte(index)) < 0x80
5573
- index += 1
5574
- byte0
5575
- elsif (byte1 = buff.getbyte(index + 1)) < 0x80
5576
- index += 2
5577
- (byte1 << 7) | (byte0 & 0x7F)
5578
- elsif (byte2 = buff.getbyte(index + 2)) < 0x80
5579
- index += 3
5580
- (byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
5581
- elsif (byte3 = buff.getbyte(index + 3)) < 0x80
5582
- index += 4
5583
- (byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
5584
- (byte0 & 0x7F)
5585
- elsif (byte4 = buff.getbyte(index + 4)) < 0x80
5586
- index += 5
5587
- (byte4 << 28) | ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
5588
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
5589
- elsif (byte5 = buff.getbyte(index + 5)) < 0x80
5590
- index += 6
5591
- (byte5 << 35) | ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
5592
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
5593
- elsif (byte6 = buff.getbyte(index + 6)) < 0x80
5594
- index += 7
5595
- (byte6 << 42) | ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
5596
- ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
5597
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
5598
- elsif (byte7 = buff.getbyte(index + 7)) < 0x80
5599
- index += 8
5600
- (byte7 << 49) | ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
5601
- ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
5602
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
5603
- elsif (byte8 = buff.getbyte(index + 8)) < 0x80
5604
- index += 9
5605
- (byte8 << 56) | ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
5606
- ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
5607
- ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
5608
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
5609
- elsif (byte9 = buff.getbyte(index + 9)) < 0x80
5610
- index += 10
5611
-
5612
- (byte9 << 63) | ((byte8 & 0x7F) << 56) | ((byte7 & 0x7F) << 49) |
5613
- ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
5614
- ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
5615
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
5616
- else
5617
- raise "integer decoding error"
5618
- end
5619
-
5620
- ## END PULL_UINT64
5621
-
5622
- goal = index + value
5766
+ ## DECODE REPEATED
5623
5767
  list = @tech_alias
5624
5768
  while true
5625
- break if index >= goal
5626
5769
  ## PULL_UINT64
5627
5770
  list << if (byte0 = buff.getbyte(index)) < 0x80
5628
5771
  index += 1
@@ -5673,60 +5816,71 @@ module Api
5673
5816
  end
5674
5817
 
5675
5818
  ## END PULL_UINT64
5676
- end
5677
5819
 
5678
- return self if index >= len
5679
- ## PULL_UINT64
5680
- tag =
5681
- if (byte0 = buff.getbyte(index)) < 0x80
5682
- index += 1
5683
- byte0
5684
- elsif (byte1 = buff.getbyte(index + 1)) < 0x80
5685
- index += 2
5686
- (byte1 << 7) | (byte0 & 0x7F)
5687
- elsif (byte2 = buff.getbyte(index + 2)) < 0x80
5688
- index += 3
5689
- (byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
5690
- elsif (byte3 = buff.getbyte(index + 3)) < 0x80
5691
- index += 4
5692
- (byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
5693
- (byte0 & 0x7F)
5694
- elsif (byte4 = buff.getbyte(index + 4)) < 0x80
5695
- index += 5
5696
- (byte4 << 28) | ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
5697
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
5698
- elsif (byte5 = buff.getbyte(index + 5)) < 0x80
5699
- index += 6
5700
- (byte5 << 35) | ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
5701
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
5702
- elsif (byte6 = buff.getbyte(index + 6)) < 0x80
5703
- index += 7
5704
- (byte6 << 42) | ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
5705
- ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
5706
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
5707
- elsif (byte7 = buff.getbyte(index + 7)) < 0x80
5708
- index += 8
5709
- (byte7 << 49) | ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
5710
- ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
5711
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
5712
- elsif (byte8 = buff.getbyte(index + 8)) < 0x80
5713
- index += 9
5714
- (byte8 << 56) | ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
5715
- ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
5716
- ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
5717
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
5718
- elsif (byte9 = buff.getbyte(index + 9)) < 0x80
5719
- index += 10
5820
+ return self if index >= len
5821
+ ## PULL_UINT64
5822
+ tag =
5823
+ if (byte0 = buff.getbyte(index)) < 0x80
5824
+ index += 1
5825
+ byte0
5826
+ elsif (byte1 = buff.getbyte(index + 1)) < 0x80
5827
+ index += 2
5828
+ (byte1 << 7) | (byte0 & 0x7F)
5829
+ elsif (byte2 = buff.getbyte(index + 2)) < 0x80
5830
+ index += 3
5831
+ (byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
5832
+ elsif (byte3 = buff.getbyte(index + 3)) < 0x80
5833
+ index += 4
5834
+ (byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
5835
+ (byte0 & 0x7F)
5836
+ elsif (byte4 = buff.getbyte(index + 4)) < 0x80
5837
+ index += 5
5838
+ (byte4 << 28) | ((byte3 & 0x7F) << 21) |
5839
+ ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
5840
+ (byte0 & 0x7F)
5841
+ elsif (byte5 = buff.getbyte(index + 5)) < 0x80
5842
+ index += 6
5843
+ (byte5 << 35) | ((byte4 & 0x7F) << 28) |
5844
+ ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
5845
+ ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
5846
+ elsif (byte6 = buff.getbyte(index + 6)) < 0x80
5847
+ index += 7
5848
+ (byte6 << 42) | ((byte5 & 0x7F) << 35) |
5849
+ ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
5850
+ ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
5851
+ (byte0 & 0x7F)
5852
+ elsif (byte7 = buff.getbyte(index + 7)) < 0x80
5853
+ index += 8
5854
+ (byte7 << 49) | ((byte6 & 0x7F) << 42) |
5855
+ ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
5856
+ ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
5857
+ ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
5858
+ elsif (byte8 = buff.getbyte(index + 8)) < 0x80
5859
+ index += 9
5860
+ (byte8 << 56) | ((byte7 & 0x7F) << 49) |
5861
+ ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
5862
+ ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
5863
+ ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
5864
+ (byte0 & 0x7F)
5865
+ elsif (byte9 = buff.getbyte(index + 9)) < 0x80
5866
+ index += 10
5720
5867
 
5721
- (byte9 << 63) | ((byte8 & 0x7F) << 56) | ((byte7 & 0x7F) << 49) |
5722
- ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
5723
- ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
5724
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
5725
- else
5726
- raise "integer decoding error"
5727
- end
5868
+ (byte9 << 63) | ((byte8 & 0x7F) << 56) |
5869
+ ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
5870
+ ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
5871
+ ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
5872
+ ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
5873
+ else
5874
+ raise "integer decoding error"
5875
+ end
5728
5876
 
5729
- ## END PULL_UINT64
5877
+ ## END PULL_UINT64
5878
+
5879
+ break unless tag == 0xa8
5880
+ end
5881
+ ## END DECODE REPEATED
5882
+
5883
+ return self if index >= len
5730
5884
  end
5731
5885
  if tag == 0xb0
5732
5886
  found = true
@@ -6396,86 +6550,91 @@ module Api
6396
6550
  end
6397
6551
  def _encode(buff)
6398
6552
  val = @unit_id
6399
- if val != 0
6553
+ if has_unit_id?
6400
6554
  buff << 0x08
6401
6555
 
6402
- while val != 0
6556
+ loop do
6403
6557
  byte = val & 0x7F
6404
6558
  val >>= 7
6405
6559
  byte |= 0x80 if val > 0
6406
6560
  buff << byte
6561
+ break if val == 0
6407
6562
  end
6408
6563
  end
6409
6564
 
6410
6565
  val = @name
6411
- if ((len = val.bytesize) > 0)
6566
+ if (len = val.bytesize) > 0 || has_name?
6412
6567
  buff << 0x12
6413
- while len != 0
6568
+ loop do
6414
6569
  byte = len & 0x7F
6415
6570
  len >>= 7
6416
6571
  byte |= 0x80 if len > 0
6417
6572
  buff << byte
6573
+ break if len == 0
6418
6574
  end
6419
6575
 
6420
6576
  buff << (val.ascii_only? ? val : val.b)
6421
6577
  end
6422
6578
 
6423
- val = @available
6424
- if val == true
6579
+ if has_available?
6580
+ val = @available
6425
6581
  buff << 0x18
6426
6582
 
6427
- buff << 1
6428
- elsif val == false
6429
- # Default value, encode nothing
6430
- else
6431
- raise "bool values should be true or false"
6583
+ if val == true
6584
+ buff << 1
6585
+ elsif val == false
6586
+ buff << 0
6587
+ end
6432
6588
  end
6433
6589
 
6434
6590
  val = @cargo_size
6435
- if val != 0
6591
+ if has_cargo_size?
6436
6592
  buff << 0x20
6437
6593
 
6438
- while val != 0
6594
+ loop do
6439
6595
  byte = val & 0x7F
6440
6596
  val >>= 7
6441
6597
  byte |= 0x80 if val > 0
6442
6598
  buff << byte
6599
+ break if val == 0
6443
6600
  end
6444
6601
  end
6445
6602
 
6446
6603
  val = @mineral_cost
6447
- if val != 0
6604
+ if has_mineral_cost?
6448
6605
  buff << 0x60
6449
6606
 
6450
- while val != 0
6607
+ loop do
6451
6608
  byte = val & 0x7F
6452
6609
  val >>= 7
6453
6610
  byte |= 0x80 if val > 0
6454
6611
  buff << byte
6612
+ break if val == 0
6455
6613
  end
6456
6614
  end
6457
6615
 
6458
6616
  val = @vespene_cost
6459
- if val != 0
6617
+ if has_vespene_cost?
6460
6618
  buff << 0x68
6461
6619
 
6462
- while val != 0
6620
+ loop do
6463
6621
  byte = val & 0x7F
6464
6622
  val >>= 7
6465
6623
  byte |= 0x80 if val > 0
6466
6624
  buff << byte
6625
+ break if val == 0
6467
6626
  end
6468
6627
  end
6469
6628
 
6470
6629
  val = @food_required
6471
- if val != 0
6630
+ if has_food_required?
6472
6631
  buff << 0x75
6473
6632
 
6474
6633
  [val].pack("e", buffer: buff)
6475
6634
  end
6476
6635
 
6477
6636
  val = @food_provided
6478
- if val != 0
6637
+ if has_food_provided?
6479
6638
  buff << 0x95
6480
6639
  buff << 0x01
6481
6640
 
@@ -6483,23 +6642,24 @@ module Api
6483
6642
  end
6484
6643
 
6485
6644
  val = @ability_id
6486
- if val != 0
6645
+ if has_ability_id?
6487
6646
  buff << 0x78
6488
6647
 
6489
- while val != 0
6648
+ loop do
6490
6649
  byte = val & 0x7F
6491
6650
  val >>= 7
6492
6651
  byte |= 0x80 if val > 0
6493
6652
  buff << byte
6653
+ break if val == 0
6494
6654
  end
6495
6655
  end
6496
6656
 
6497
6657
  val = @race
6498
- if val != 0
6658
+ if has_race?
6499
6659
  buff << 0x80
6500
6660
  buff << 0x01
6501
6661
 
6502
- while val != 0
6662
+ loop do
6503
6663
  byte = val & 0x7F
6504
6664
 
6505
6665
  val >>= 7
@@ -6510,43 +6670,44 @@ module Api
6510
6670
 
6511
6671
  byte |= 0x80 if val != 0
6512
6672
  buff << byte
6673
+ break if val == 0
6513
6674
  end
6514
6675
  end
6515
6676
 
6516
6677
  val = @build_time
6517
- if val != 0
6678
+ if has_build_time?
6518
6679
  buff << 0x8d
6519
6680
  buff << 0x01
6520
6681
 
6521
6682
  [val].pack("e", buffer: buff)
6522
6683
  end
6523
6684
 
6524
- val = @has_vespene
6525
- if val == true
6685
+ if has_has_vespene?
6686
+ val = @has_vespene
6526
6687
  buff << 0x98
6527
6688
  buff << 0x01
6528
6689
 
6529
- buff << 1
6530
- elsif val == false
6531
- # Default value, encode nothing
6532
- else
6533
- raise "bool values should be true or false"
6690
+ if val == true
6691
+ buff << 1
6692
+ elsif val == false
6693
+ buff << 0
6694
+ end
6534
6695
  end
6535
6696
 
6536
- val = @has_minerals
6537
- if val == true
6697
+ if has_has_minerals?
6698
+ val = @has_minerals
6538
6699
  buff << 0xa0
6539
6700
  buff << 0x01
6540
6701
 
6541
- buff << 1
6542
- elsif val == false
6543
- # Default value, encode nothing
6544
- else
6545
- raise "bool values should be true or false"
6702
+ if val == true
6703
+ buff << 1
6704
+ elsif val == false
6705
+ buff << 0
6706
+ end
6546
6707
  end
6547
6708
 
6548
6709
  val = @sight_range
6549
- if val != 0
6710
+ if has_sight_range?
6550
6711
  buff << 0xcd
6551
6712
  buff << 0x01
6552
6713
 
@@ -6555,99 +6716,61 @@ module Api
6555
6716
 
6556
6717
  list = @tech_alias
6557
6718
  if list.size > 0
6558
- buff << 0xaa
6559
- buff << 0x01
6560
-
6561
- # Save the buffer size before appending the repeated bytes
6562
- current_len = buff.bytesize
6563
-
6564
- # Write a single dummy byte to later store encoded length
6565
- buff << 42 # "*"
6566
-
6567
- # write each item
6568
6719
  list.each do |item|
6569
6720
  val = item
6570
6721
  if val != 0
6571
- while val != 0
6722
+ buff << 0xa8
6723
+ buff << 0x01
6724
+
6725
+ loop do
6572
6726
  byte = val & 0x7F
6573
6727
  val >>= 7
6574
6728
  byte |= 0x80 if val > 0
6575
6729
  buff << byte
6730
+ break if val == 0
6576
6731
  end
6577
6732
  end
6578
6733
  end
6579
-
6580
- # Calculate the submessage's size
6581
- submessage_size = buff.bytesize - current_len - 1
6582
-
6583
- # Hope the size fits in one byte
6584
- byte = submessage_size & 0x7F
6585
- submessage_size >>= 7
6586
- byte |= 0x80 if submessage_size > 0
6587
- buff.setbyte(current_len, byte)
6588
-
6589
- # If the sub message was bigger
6590
- if submessage_size > 0
6591
- current_len += 1
6592
-
6593
- # compute how much we need to shift
6594
- encoded_int_len = 0
6595
- remaining_size = submessage_size
6596
- while remaining_size != 0
6597
- remaining_size >>= 7
6598
- encoded_int_len += 1
6599
- end
6600
-
6601
- # Make space in the string with dummy bytes
6602
- buff.bytesplice(current_len, 0, "*********", 0, encoded_int_len)
6603
-
6604
- # Overwrite the dummy bytes with the encoded length
6605
- while submessage_size != 0
6606
- byte = submessage_size & 0x7F
6607
- submessage_size >>= 7
6608
- byte |= 0x80 if submessage_size > 0
6609
- buff.setbyte(current_len, byte)
6610
- current_len += 1
6611
- end
6612
- end
6613
6734
  end
6614
6735
 
6615
6736
  val = @unit_alias
6616
- if val != 0
6737
+ if has_unit_alias?
6617
6738
  buff << 0xb0
6618
6739
  buff << 0x01
6619
6740
 
6620
- while val != 0
6741
+ loop do
6621
6742
  byte = val & 0x7F
6622
6743
  val >>= 7
6623
6744
  byte |= 0x80 if val > 0
6624
6745
  buff << byte
6746
+ break if val == 0
6625
6747
  end
6626
6748
  end
6627
6749
 
6628
6750
  val = @tech_requirement
6629
- if val != 0
6751
+ if has_tech_requirement?
6630
6752
  buff << 0xb8
6631
6753
  buff << 0x01
6632
6754
 
6633
- while val != 0
6755
+ loop do
6634
6756
  byte = val & 0x7F
6635
6757
  val >>= 7
6636
6758
  byte |= 0x80 if val > 0
6637
6759
  buff << byte
6760
+ break if val == 0
6638
6761
  end
6639
6762
  end
6640
6763
 
6641
- val = @require_attached
6642
- if val == true
6764
+ if has_require_attached?
6765
+ val = @require_attached
6643
6766
  buff << 0xc0
6644
6767
  buff << 0x01
6645
6768
 
6646
- buff << 1
6647
- elsif val == false
6648
- # Default value, encode nothing
6649
- else
6650
- raise "bool values should be true or false"
6769
+ if val == true
6770
+ buff << 1
6771
+ elsif val == false
6772
+ buff << 0
6773
+ end
6651
6774
  end
6652
6775
 
6653
6776
  list = @attributes
@@ -6657,7 +6780,7 @@ module Api
6657
6780
  if val != 0
6658
6781
  buff << 0x40
6659
6782
 
6660
- while val != 0
6783
+ loop do
6661
6784
  byte = val & 0x7F
6662
6785
 
6663
6786
  val >>= 7
@@ -6668,20 +6791,21 @@ module Api
6668
6791
 
6669
6792
  byte |= 0x80 if val != 0
6670
6793
  buff << byte
6794
+ break if val == 0
6671
6795
  end
6672
6796
  end
6673
6797
  end
6674
6798
  end
6675
6799
 
6676
6800
  val = @movement_speed
6677
- if val != 0
6801
+ if has_movement_speed?
6678
6802
  buff << 0x4d
6679
6803
 
6680
6804
  [val].pack("e", buffer: buff)
6681
6805
  end
6682
6806
 
6683
6807
  val = @armor
6684
- if val != 0
6808
+ if has_armor?
6685
6809
  buff << 0x55
6686
6810
 
6687
6811
  [val].pack("e", buffer: buff)
@@ -6739,36 +6863,93 @@ module Api
6739
6863
  end
6740
6864
  end
6741
6865
  end
6742
-
6866
+ buff << @_unknown_fields if @_unknown_fields
6743
6867
  buff
6744
6868
  end
6745
6869
 
6746
6870
  def to_h
6747
6871
  result = {}
6748
- result["unit_id".to_sym] = @unit_id
6749
- result["name".to_sym] = @name
6750
- result["available".to_sym] = @available
6751
- result["cargo_size".to_sym] = @cargo_size
6752
- result["mineral_cost".to_sym] = @mineral_cost
6753
- result["vespene_cost".to_sym] = @vespene_cost
6754
- result["food_required".to_sym] = @food_required
6755
- result["food_provided".to_sym] = @food_provided
6756
- result["ability_id".to_sym] = @ability_id
6757
- result["race".to_sym] = @race
6758
- result["build_time".to_sym] = @build_time
6759
- result["has_vespene".to_sym] = @has_vespene
6760
- result["has_minerals".to_sym] = @has_minerals
6761
- result["sight_range".to_sym] = @sight_range
6762
- result["tech_alias".to_sym] = @tech_alias
6763
- result["unit_alias".to_sym] = @unit_alias
6764
- result["tech_requirement".to_sym] = @tech_requirement
6765
- result["require_attached".to_sym] = @require_attached
6766
- result["attributes".to_sym] = @attributes
6767
- result["movement_speed".to_sym] = @movement_speed
6768
- result["armor".to_sym] = @armor
6769
- result["weapons".to_sym] = @weapons
6872
+
6873
+ result[:"unit_id"] = @unit_id
6874
+ result[:"name"] = @name
6875
+ result[:"available"] = @available
6876
+ result[:"cargo_size"] = @cargo_size
6877
+ result[:"attributes"] = @attributes
6878
+ result[:"movement_speed"] = @movement_speed
6879
+ result[:"armor"] = @armor
6880
+ result[:"weapons"] = @weapons.map(&:to_h)
6881
+ result[:"mineral_cost"] = @mineral_cost
6882
+ result[:"vespene_cost"] = @vespene_cost
6883
+ result[:"food_required"] = @food_required
6884
+ result[:"ability_id"] = @ability_id
6885
+ result[:"race"] = @race
6886
+ result[:"build_time"] = @build_time
6887
+ result[:"food_provided"] = @food_provided
6888
+ result[:"has_vespene"] = @has_vespene
6889
+ result[:"has_minerals"] = @has_minerals
6890
+ result[:"tech_alias"] = @tech_alias
6891
+ result[:"unit_alias"] = @unit_alias
6892
+ result[:"tech_requirement"] = @tech_requirement
6893
+ result[:"require_attached"] = @require_attached
6894
+ result[:"sight_range"] = @sight_range
6895
+
6770
6896
  result
6771
6897
  end
6898
+
6899
+ def as_json(options = {})
6900
+ result = {}
6901
+
6902
+ result["unitId"] = @unit_id if !options[:compact] || has_unit_id?
6903
+ result["name"] = @name if !options[:compact] || has_name?
6904
+ result["available"] = @available if !options[:compact] || has_available?
6905
+ result["cargoSize"] = @cargo_size if !options[:compact] || has_cargo_size?
6906
+ tmp_attributes = @attributes
6907
+
6908
+ result["attributes"] = tmp_attributes if !options[:compact] ||
6909
+ tmp_attributes.any?
6910
+
6911
+ result["movementSpeed"] = @movement_speed if !options[:compact] ||
6912
+ has_movement_speed?
6913
+ result["armor"] = @armor if !options[:compact] || has_armor?
6914
+ tmp_weapons = @weapons.map { |v| v.as_json(options) }
6915
+
6916
+ result["weapons"] = tmp_weapons if !options[:compact] || tmp_weapons.any?
6917
+
6918
+ result["mineralCost"] = @mineral_cost if !options[:compact] ||
6919
+ has_mineral_cost?
6920
+ result["vespeneCost"] = @vespene_cost if !options[:compact] ||
6921
+ has_vespene_cost?
6922
+ result["foodRequired"] = @food_required if !options[:compact] ||
6923
+ has_food_required?
6924
+ result["abilityId"] = @ability_id if !options[:compact] || has_ability_id?
6925
+ result["race"] = @race if !options[:compact] || has_race?
6926
+ result["buildTime"] = @build_time if !options[:compact] || has_build_time?
6927
+ result["foodProvided"] = @food_provided if !options[:compact] ||
6928
+ has_food_provided?
6929
+ result["hasVespene"] = @has_vespene if !options[:compact] ||
6930
+ has_has_vespene?
6931
+ result["hasMinerals"] = @has_minerals if !options[:compact] ||
6932
+ has_has_minerals?
6933
+ tmp_tech_alias = @tech_alias
6934
+
6935
+ result["techAlias"] = tmp_tech_alias if !options[:compact] ||
6936
+ tmp_tech_alias.any?
6937
+
6938
+ result["unitAlias"] = @unit_alias if !options[:compact] || has_unit_alias?
6939
+ result["techRequirement"] = @tech_requirement if !options[:compact] ||
6940
+ has_tech_requirement?
6941
+ result["requireAttached"] = @require_attached if !options[:compact] ||
6942
+ has_require_attached?
6943
+ result["sightRange"] = @sight_range if !options[:compact] ||
6944
+ has_sight_range?
6945
+
6946
+ result
6947
+ end
6948
+
6949
+ def to_json(as_json_options = {})
6950
+ require "json"
6951
+ JSON.dump(as_json(as_json_options))
6952
+ end
6772
6953
  end
6773
6954
  class UpgradeData
6774
6955
  def self.decode(buff)
@@ -7013,20 +7194,39 @@ module Api
7013
7194
  # unexpected, so discard it and continue.
7014
7195
  if !found
7015
7196
  wire_type = tag & 0x7
7197
+
7198
+ unknown_bytes = +"".b
7199
+ val = tag
7200
+ loop do
7201
+ byte = val & 0x7F
7202
+
7203
+ val >>= 7
7204
+ # This drops the top bits,
7205
+ # Otherwise, with a signed right shift,
7206
+ # we get infinity one bits at the top
7207
+ val &= (1 << 57) - 1
7208
+
7209
+ byte |= 0x80 if val != 0
7210
+ unknown_bytes << byte
7211
+ break if val == 0
7212
+ end
7213
+
7016
7214
  case wire_type
7017
7215
  when 0
7018
7216
  i = 0
7019
7217
  while true
7020
7218
  newbyte = buff.getbyte(index)
7021
7219
  index += 1
7022
- break if newbyte.nil? || newbyte < 0x80
7220
+ break if newbyte.nil?
7221
+ unknown_bytes << newbyte
7222
+ break if newbyte < 0x80
7023
7223
  i += 1
7024
7224
  break if i > 9
7025
7225
  end
7026
7226
  when 1
7227
+ unknown_bytes << buff.byteslice(index, 8)
7027
7228
  index += 8
7028
7229
  when 2
7029
- ## PULL_BYTES
7030
7230
  value =
7031
7231
  if (byte0 = buff.getbyte(index)) < 0x80
7032
7232
  index += 1
@@ -7082,15 +7282,30 @@ module Api
7082
7282
  raise "integer decoding error"
7083
7283
  end
7084
7284
 
7085
- buff.byteslice(index, value)
7086
- index += value
7285
+ val = value
7286
+ loop do
7287
+ byte = val & 0x7F
7288
+
7289
+ val >>= 7
7290
+ # This drops the top bits,
7291
+ # Otherwise, with a signed right shift,
7292
+ # we get infinity one bits at the top
7293
+ val &= (1 << 57) - 1
7087
7294
 
7088
- ## END PULL_BYTES
7295
+ byte |= 0x80 if val != 0
7296
+ unknown_bytes << byte
7297
+ break if val == 0
7298
+ end
7299
+
7300
+ unknown_bytes << buff.byteslice(index, value)
7301
+ index += value
7089
7302
  when 5
7303
+ unknown_bytes << buff.byteslice(index, 4)
7090
7304
  index += 4
7091
7305
  else
7092
7306
  raise "unknown wire type #{wire_type}"
7093
7307
  end
7308
+ (@_unknown_fields ||= +"".b) << unknown_bytes
7094
7309
  return self if index >= len
7095
7310
  ## PULL_UINT64
7096
7311
  tag =
@@ -7753,86 +7968,114 @@ module Api
7753
7968
  end
7754
7969
  def _encode(buff)
7755
7970
  val = @upgrade_id
7756
- if val != 0
7971
+ if has_upgrade_id?
7757
7972
  buff << 0x08
7758
7973
 
7759
- while val != 0
7974
+ loop do
7760
7975
  byte = val & 0x7F
7761
7976
  val >>= 7
7762
7977
  byte |= 0x80 if val > 0
7763
7978
  buff << byte
7979
+ break if val == 0
7764
7980
  end
7765
7981
  end
7766
7982
 
7767
7983
  val = @name
7768
- if ((len = val.bytesize) > 0)
7984
+ if (len = val.bytesize) > 0 || has_name?
7769
7985
  buff << 0x12
7770
- while len != 0
7986
+ loop do
7771
7987
  byte = len & 0x7F
7772
7988
  len >>= 7
7773
7989
  byte |= 0x80 if len > 0
7774
7990
  buff << byte
7991
+ break if len == 0
7775
7992
  end
7776
7993
 
7777
7994
  buff << (val.ascii_only? ? val : val.b)
7778
7995
  end
7779
7996
 
7780
7997
  val = @mineral_cost
7781
- if val != 0
7998
+ if has_mineral_cost?
7782
7999
  buff << 0x18
7783
8000
 
7784
- while val != 0
8001
+ loop do
7785
8002
  byte = val & 0x7F
7786
8003
  val >>= 7
7787
8004
  byte |= 0x80 if val > 0
7788
8005
  buff << byte
8006
+ break if val == 0
7789
8007
  end
7790
8008
  end
7791
8009
 
7792
8010
  val = @vespene_cost
7793
- if val != 0
8011
+ if has_vespene_cost?
7794
8012
  buff << 0x20
7795
8013
 
7796
- while val != 0
8014
+ loop do
7797
8015
  byte = val & 0x7F
7798
8016
  val >>= 7
7799
8017
  byte |= 0x80 if val > 0
7800
8018
  buff << byte
8019
+ break if val == 0
7801
8020
  end
7802
8021
  end
7803
8022
 
7804
8023
  val = @research_time
7805
- if val != 0
8024
+ if has_research_time?
7806
8025
  buff << 0x2d
7807
8026
 
7808
8027
  [val].pack("e", buffer: buff)
7809
8028
  end
7810
8029
 
7811
8030
  val = @ability_id
7812
- if val != 0
8031
+ if has_ability_id?
7813
8032
  buff << 0x30
7814
8033
 
7815
- while val != 0
8034
+ loop do
7816
8035
  byte = val & 0x7F
7817
8036
  val >>= 7
7818
8037
  byte |= 0x80 if val > 0
7819
8038
  buff << byte
8039
+ break if val == 0
7820
8040
  end
7821
8041
  end
7822
-
8042
+ buff << @_unknown_fields if @_unknown_fields
7823
8043
  buff
7824
8044
  end
7825
8045
 
7826
8046
  def to_h
7827
8047
  result = {}
7828
- result["upgrade_id".to_sym] = @upgrade_id
7829
- result["name".to_sym] = @name
7830
- result["mineral_cost".to_sym] = @mineral_cost
7831
- result["vespene_cost".to_sym] = @vespene_cost
7832
- result["research_time".to_sym] = @research_time
7833
- result["ability_id".to_sym] = @ability_id
8048
+
8049
+ result[:"upgrade_id"] = @upgrade_id
8050
+ result[:"name"] = @name
8051
+ result[:"mineral_cost"] = @mineral_cost
8052
+ result[:"vespene_cost"] = @vespene_cost
8053
+ result[:"research_time"] = @research_time
8054
+ result[:"ability_id"] = @ability_id
8055
+
8056
+ result
8057
+ end
8058
+
8059
+ def as_json(options = {})
8060
+ result = {}
8061
+
8062
+ result["upgradeId"] = @upgrade_id if !options[:compact] || has_upgrade_id?
8063
+ result["name"] = @name if !options[:compact] || has_name?
8064
+ result["mineralCost"] = @mineral_cost if !options[:compact] ||
8065
+ has_mineral_cost?
8066
+ result["vespeneCost"] = @vespene_cost if !options[:compact] ||
8067
+ has_vespene_cost?
8068
+ result["researchTime"] = @research_time if !options[:compact] ||
8069
+ has_research_time?
8070
+ result["abilityId"] = @ability_id if !options[:compact] || has_ability_id?
8071
+
7834
8072
  result
7835
8073
  end
8074
+
8075
+ def to_json(as_json_options = {})
8076
+ require "json"
8077
+ JSON.dump(as_json(as_json_options))
8078
+ end
7836
8079
  end
7837
8080
  class BuffData
7838
8081
  def self.decode(buff)
@@ -7967,20 +8210,39 @@ module Api
7967
8210
  # unexpected, so discard it and continue.
7968
8211
  if !found
7969
8212
  wire_type = tag & 0x7
8213
+
8214
+ unknown_bytes = +"".b
8215
+ val = tag
8216
+ loop do
8217
+ byte = val & 0x7F
8218
+
8219
+ val >>= 7
8220
+ # This drops the top bits,
8221
+ # Otherwise, with a signed right shift,
8222
+ # we get infinity one bits at the top
8223
+ val &= (1 << 57) - 1
8224
+
8225
+ byte |= 0x80 if val != 0
8226
+ unknown_bytes << byte
8227
+ break if val == 0
8228
+ end
8229
+
7970
8230
  case wire_type
7971
8231
  when 0
7972
8232
  i = 0
7973
8233
  while true
7974
8234
  newbyte = buff.getbyte(index)
7975
8235
  index += 1
7976
- break if newbyte.nil? || newbyte < 0x80
8236
+ break if newbyte.nil?
8237
+ unknown_bytes << newbyte
8238
+ break if newbyte < 0x80
7977
8239
  i += 1
7978
8240
  break if i > 9
7979
8241
  end
7980
8242
  when 1
8243
+ unknown_bytes << buff.byteslice(index, 8)
7981
8244
  index += 8
7982
8245
  when 2
7983
- ## PULL_BYTES
7984
8246
  value =
7985
8247
  if (byte0 = buff.getbyte(index)) < 0x80
7986
8248
  index += 1
@@ -8036,15 +8298,30 @@ module Api
8036
8298
  raise "integer decoding error"
8037
8299
  end
8038
8300
 
8039
- buff.byteslice(index, value)
8040
- index += value
8301
+ val = value
8302
+ loop do
8303
+ byte = val & 0x7F
8041
8304
 
8042
- ## END PULL_BYTES
8305
+ val >>= 7
8306
+ # This drops the top bits,
8307
+ # Otherwise, with a signed right shift,
8308
+ # we get infinity one bits at the top
8309
+ val &= (1 << 57) - 1
8310
+
8311
+ byte |= 0x80 if val != 0
8312
+ unknown_bytes << byte
8313
+ break if val == 0
8314
+ end
8315
+
8316
+ unknown_bytes << buff.byteslice(index, value)
8317
+ index += value
8043
8318
  when 5
8319
+ unknown_bytes << buff.byteslice(index, 4)
8044
8320
  index += 4
8045
8321
  else
8046
8322
  raise "unknown wire type #{wire_type}"
8047
8323
  end
8324
+ (@_unknown_fields ||= +"".b) << unknown_bytes
8048
8325
  return self if index >= len
8049
8326
  ## PULL_UINT64
8050
8327
  tag =
@@ -8325,39 +8602,57 @@ module Api
8325
8602
  end
8326
8603
  def _encode(buff)
8327
8604
  val = @buff_id
8328
- if val != 0
8605
+ if has_buff_id?
8329
8606
  buff << 0x08
8330
8607
 
8331
- while val != 0
8608
+ loop do
8332
8609
  byte = val & 0x7F
8333
8610
  val >>= 7
8334
8611
  byte |= 0x80 if val > 0
8335
8612
  buff << byte
8613
+ break if val == 0
8336
8614
  end
8337
8615
  end
8338
8616
 
8339
8617
  val = @name
8340
- if ((len = val.bytesize) > 0)
8618
+ if (len = val.bytesize) > 0 || has_name?
8341
8619
  buff << 0x12
8342
- while len != 0
8620
+ loop do
8343
8621
  byte = len & 0x7F
8344
8622
  len >>= 7
8345
8623
  byte |= 0x80 if len > 0
8346
8624
  buff << byte
8625
+ break if len == 0
8347
8626
  end
8348
8627
 
8349
8628
  buff << (val.ascii_only? ? val : val.b)
8350
8629
  end
8351
-
8630
+ buff << @_unknown_fields if @_unknown_fields
8352
8631
  buff
8353
8632
  end
8354
8633
 
8355
8634
  def to_h
8356
8635
  result = {}
8357
- result["buff_id".to_sym] = @buff_id
8358
- result["name".to_sym] = @name
8636
+
8637
+ result[:"buff_id"] = @buff_id
8638
+ result[:"name"] = @name
8639
+
8359
8640
  result
8360
8641
  end
8642
+
8643
+ def as_json(options = {})
8644
+ result = {}
8645
+
8646
+ result["buffId"] = @buff_id if !options[:compact] || has_buff_id?
8647
+ result["name"] = @name if !options[:compact] || has_name?
8648
+
8649
+ result
8650
+ end
8651
+
8652
+ def to_json(as_json_options = {})
8653
+ require "json"
8654
+ JSON.dump(as_json(as_json_options))
8655
+ end
8361
8656
  end
8362
8657
  class EffectData
8363
8658
  def self.decode(buff)
@@ -8530,20 +8825,39 @@ module Api
8530
8825
  # unexpected, so discard it and continue.
8531
8826
  if !found
8532
8827
  wire_type = tag & 0x7
8828
+
8829
+ unknown_bytes = +"".b
8830
+ val = tag
8831
+ loop do
8832
+ byte = val & 0x7F
8833
+
8834
+ val >>= 7
8835
+ # This drops the top bits,
8836
+ # Otherwise, with a signed right shift,
8837
+ # we get infinity one bits at the top
8838
+ val &= (1 << 57) - 1
8839
+
8840
+ byte |= 0x80 if val != 0
8841
+ unknown_bytes << byte
8842
+ break if val == 0
8843
+ end
8844
+
8533
8845
  case wire_type
8534
8846
  when 0
8535
8847
  i = 0
8536
8848
  while true
8537
8849
  newbyte = buff.getbyte(index)
8538
8850
  index += 1
8539
- break if newbyte.nil? || newbyte < 0x80
8851
+ break if newbyte.nil?
8852
+ unknown_bytes << newbyte
8853
+ break if newbyte < 0x80
8540
8854
  i += 1
8541
8855
  break if i > 9
8542
8856
  end
8543
8857
  when 1
8858
+ unknown_bytes << buff.byteslice(index, 8)
8544
8859
  index += 8
8545
8860
  when 2
8546
- ## PULL_BYTES
8547
8861
  value =
8548
8862
  if (byte0 = buff.getbyte(index)) < 0x80
8549
8863
  index += 1
@@ -8599,15 +8913,30 @@ module Api
8599
8913
  raise "integer decoding error"
8600
8914
  end
8601
8915
 
8602
- buff.byteslice(index, value)
8603
- index += value
8916
+ val = value
8917
+ loop do
8918
+ byte = val & 0x7F
8919
+
8920
+ val >>= 7
8921
+ # This drops the top bits,
8922
+ # Otherwise, with a signed right shift,
8923
+ # we get infinity one bits at the top
8924
+ val &= (1 << 57) - 1
8925
+
8926
+ byte |= 0x80 if val != 0
8927
+ unknown_bytes << byte
8928
+ break if val == 0
8929
+ end
8604
8930
 
8605
- ## END PULL_BYTES
8931
+ unknown_bytes << buff.byteslice(index, value)
8932
+ index += value
8606
8933
  when 5
8934
+ unknown_bytes << buff.byteslice(index, 4)
8607
8935
  index += 4
8608
8936
  else
8609
8937
  raise "unknown wire type #{wire_type}"
8610
8938
  end
8939
+ (@_unknown_fields ||= +"".b) << unknown_bytes
8611
8940
  return self if index >= len
8612
8941
  ## PULL_UINT64
8613
8942
  tag =
@@ -9058,60 +9387,82 @@ module Api
9058
9387
  end
9059
9388
  def _encode(buff)
9060
9389
  val = @effect_id
9061
- if val != 0
9390
+ if has_effect_id?
9062
9391
  buff << 0x08
9063
9392
 
9064
- while val != 0
9393
+ loop do
9065
9394
  byte = val & 0x7F
9066
9395
  val >>= 7
9067
9396
  byte |= 0x80 if val > 0
9068
9397
  buff << byte
9398
+ break if val == 0
9069
9399
  end
9070
9400
  end
9071
9401
 
9072
9402
  val = @name
9073
- if ((len = val.bytesize) > 0)
9403
+ if (len = val.bytesize) > 0 || has_name?
9074
9404
  buff << 0x12
9075
- while len != 0
9405
+ loop do
9076
9406
  byte = len & 0x7F
9077
9407
  len >>= 7
9078
9408
  byte |= 0x80 if len > 0
9079
9409
  buff << byte
9410
+ break if len == 0
9080
9411
  end
9081
9412
 
9082
9413
  buff << (val.ascii_only? ? val : val.b)
9083
9414
  end
9084
9415
 
9085
9416
  val = @friendly_name
9086
- if ((len = val.bytesize) > 0)
9417
+ if (len = val.bytesize) > 0 || has_friendly_name?
9087
9418
  buff << 0x1a
9088
- while len != 0
9419
+ loop do
9089
9420
  byte = len & 0x7F
9090
9421
  len >>= 7
9091
9422
  byte |= 0x80 if len > 0
9092
9423
  buff << byte
9424
+ break if len == 0
9093
9425
  end
9094
9426
 
9095
9427
  buff << (val.ascii_only? ? val : val.b)
9096
9428
  end
9097
9429
 
9098
9430
  val = @radius
9099
- if val != 0
9431
+ if has_radius?
9100
9432
  buff << 0x25
9101
9433
 
9102
9434
  [val].pack("e", buffer: buff)
9103
9435
  end
9104
-
9436
+ buff << @_unknown_fields if @_unknown_fields
9105
9437
  buff
9106
9438
  end
9107
9439
 
9108
9440
  def to_h
9109
9441
  result = {}
9110
- result["effect_id".to_sym] = @effect_id
9111
- result["name".to_sym] = @name
9112
- result["friendly_name".to_sym] = @friendly_name
9113
- result["radius".to_sym] = @radius
9442
+
9443
+ result[:"effect_id"] = @effect_id
9444
+ result[:"name"] = @name
9445
+ result[:"friendly_name"] = @friendly_name
9446
+ result[:"radius"] = @radius
9447
+
9114
9448
  result
9115
9449
  end
9450
+
9451
+ def as_json(options = {})
9452
+ result = {}
9453
+
9454
+ result["effectId"] = @effect_id if !options[:compact] || has_effect_id?
9455
+ result["name"] = @name if !options[:compact] || has_name?
9456
+ result["friendlyName"] = @friendly_name if !options[:compact] ||
9457
+ has_friendly_name?
9458
+ result["radius"] = @radius if !options[:compact] || has_radius?
9459
+
9460
+ result
9461
+ end
9462
+
9463
+ def to_json(as_json_options = {})
9464
+ require "json"
9465
+ JSON.dump(as_json(as_json_options))
9466
+ end
9116
9467
  end
9117
9468
  end