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
@@ -164,20 +164,39 @@ module Api
164
164
  # unexpected, so discard it and continue.
165
165
  if !found
166
166
  wire_type = tag & 0x7
167
+
168
+ unknown_bytes = +"".b
169
+ val = tag
170
+ loop do
171
+ byte = val & 0x7F
172
+
173
+ val >>= 7
174
+ # This drops the top bits,
175
+ # Otherwise, with a signed right shift,
176
+ # we get infinity one bits at the top
177
+ val &= (1 << 57) - 1
178
+
179
+ byte |= 0x80 if val != 0
180
+ unknown_bytes << byte
181
+ break if val == 0
182
+ end
183
+
167
184
  case wire_type
168
185
  when 0
169
186
  i = 0
170
187
  while true
171
188
  newbyte = buff.getbyte(index)
172
189
  index += 1
173
- break if newbyte.nil? || newbyte < 0x80
190
+ break if newbyte.nil?
191
+ unknown_bytes << newbyte
192
+ break if newbyte < 0x80
174
193
  i += 1
175
194
  break if i > 9
176
195
  end
177
196
  when 1
197
+ unknown_bytes << buff.byteslice(index, 8)
178
198
  index += 8
179
199
  when 2
180
- ## PULL_BYTES
181
200
  value =
182
201
  if (byte0 = buff.getbyte(index)) < 0x80
183
202
  index += 1
@@ -233,15 +252,30 @@ module Api
233
252
  raise "integer decoding error"
234
253
  end
235
254
 
236
- buff.byteslice(index, value)
237
- index += value
255
+ val = value
256
+ loop do
257
+ byte = val & 0x7F
258
+
259
+ val >>= 7
260
+ # This drops the top bits,
261
+ # Otherwise, with a signed right shift,
262
+ # we get infinity one bits at the top
263
+ val &= (1 << 57) - 1
264
+
265
+ byte |= 0x80 if val != 0
266
+ unknown_bytes << byte
267
+ break if val == 0
268
+ end
238
269
 
239
- ## END PULL_BYTES
270
+ unknown_bytes << buff.byteslice(index, value)
271
+ index += value
240
272
  when 5
273
+ unknown_bytes << buff.byteslice(index, 4)
241
274
  index += 4
242
275
  else
243
276
  raise "unknown wire type #{wire_type}"
244
277
  end
278
+ (@_unknown_fields ||= +"".b) << unknown_bytes
245
279
  return self if index >= len
246
280
  ## PULL_UINT64
247
281
  tag =
@@ -1138,16 +1172,70 @@ module Api
1138
1172
 
1139
1173
  buff
1140
1174
  end
1141
-
1175
+ buff << @_unknown_fields if @_unknown_fields
1142
1176
  buff
1143
1177
  end
1144
1178
 
1145
1179
  def to_h
1146
1180
  result = {}
1147
- send("panel").tap { |f| result[f.to_sym] = send(f) if f }
1148
- result["groups".to_sym] = @groups
1181
+
1182
+ resolved_panel = self.panel
1183
+
1184
+ result[:"groups"] = @groups.map(&:to_h)
1185
+ result[:"single"] = @single.to_h if resolved_panel == :"single"
1186
+ result[:"multi"] = @multi.to_h if resolved_panel == :"multi"
1187
+ result[:"cargo"] = @cargo.to_h if resolved_panel == :"cargo"
1188
+ result[:"production"] = @production.to_h if resolved_panel ==
1189
+ :"production"
1190
+
1191
+ result
1192
+ end
1193
+
1194
+ def as_json(options = {})
1195
+ result = {}
1196
+
1197
+ resolved_panel = self.panel
1198
+
1199
+ tmp_groups = @groups.map { |v| v.as_json(options) }
1200
+
1201
+ result["groups"] = tmp_groups if !options[:compact] || tmp_groups.any?
1202
+
1203
+ result["single"] = (
1204
+ if @single.nil?
1205
+ {}
1206
+ else
1207
+ @single.as_json(options)
1208
+ end
1209
+ ) if resolved_panel == :"single"
1210
+ result["multi"] = (
1211
+ if @multi.nil?
1212
+ {}
1213
+ else
1214
+ @multi.as_json(options)
1215
+ end
1216
+ ) if resolved_panel == :"multi"
1217
+ result["cargo"] = (
1218
+ if @cargo.nil?
1219
+ {}
1220
+ else
1221
+ @cargo.as_json(options)
1222
+ end
1223
+ ) if resolved_panel == :"cargo"
1224
+ result["production"] = (
1225
+ if @production.nil?
1226
+ {}
1227
+ else
1228
+ @production.as_json(options)
1229
+ end
1230
+ ) if resolved_panel == :"production"
1231
+
1149
1232
  result
1150
1233
  end
1234
+
1235
+ def to_json(as_json_options = {})
1236
+ require "json"
1237
+ JSON.dump(as_json(as_json_options))
1238
+ end
1151
1239
  end
1152
1240
  class ControlGroup
1153
1241
  def self.decode(buff)
@@ -1319,20 +1407,39 @@ module Api
1319
1407
  # unexpected, so discard it and continue.
1320
1408
  if !found
1321
1409
  wire_type = tag & 0x7
1410
+
1411
+ unknown_bytes = +"".b
1412
+ val = tag
1413
+ loop do
1414
+ byte = val & 0x7F
1415
+
1416
+ val >>= 7
1417
+ # This drops the top bits,
1418
+ # Otherwise, with a signed right shift,
1419
+ # we get infinity one bits at the top
1420
+ val &= (1 << 57) - 1
1421
+
1422
+ byte |= 0x80 if val != 0
1423
+ unknown_bytes << byte
1424
+ break if val == 0
1425
+ end
1426
+
1322
1427
  case wire_type
1323
1428
  when 0
1324
1429
  i = 0
1325
1430
  while true
1326
1431
  newbyte = buff.getbyte(index)
1327
1432
  index += 1
1328
- break if newbyte.nil? || newbyte < 0x80
1433
+ break if newbyte.nil?
1434
+ unknown_bytes << newbyte
1435
+ break if newbyte < 0x80
1329
1436
  i += 1
1330
1437
  break if i > 9
1331
1438
  end
1332
1439
  when 1
1440
+ unknown_bytes << buff.byteslice(index, 8)
1333
1441
  index += 8
1334
1442
  when 2
1335
- ## PULL_BYTES
1336
1443
  value =
1337
1444
  if (byte0 = buff.getbyte(index)) < 0x80
1338
1445
  index += 1
@@ -1388,15 +1495,30 @@ module Api
1388
1495
  raise "integer decoding error"
1389
1496
  end
1390
1497
 
1391
- buff.byteslice(index, value)
1392
- index += value
1498
+ val = value
1499
+ loop do
1500
+ byte = val & 0x7F
1501
+
1502
+ val >>= 7
1503
+ # This drops the top bits,
1504
+ # Otherwise, with a signed right shift,
1505
+ # we get infinity one bits at the top
1506
+ val &= (1 << 57) - 1
1507
+
1508
+ byte |= 0x80 if val != 0
1509
+ unknown_bytes << byte
1510
+ break if val == 0
1511
+ end
1393
1512
 
1394
- ## END PULL_BYTES
1513
+ unknown_bytes << buff.byteslice(index, value)
1514
+ index += value
1395
1515
  when 5
1516
+ unknown_bytes << buff.byteslice(index, 4)
1396
1517
  index += 4
1397
1518
  else
1398
1519
  raise "unknown wire type #{wire_type}"
1399
1520
  end
1521
+ (@_unknown_fields ||= +"".b) << unknown_bytes
1400
1522
  return self if index >= len
1401
1523
  ## PULL_UINT64
1402
1524
  tag =
@@ -1782,51 +1904,74 @@ module Api
1782
1904
  end
1783
1905
  def _encode(buff)
1784
1906
  val = @control_group_index
1785
- if val != 0
1907
+ if has_control_group_index?
1786
1908
  buff << 0x08
1787
1909
 
1788
- while val != 0
1910
+ loop do
1789
1911
  byte = val & 0x7F
1790
1912
  val >>= 7
1791
1913
  byte |= 0x80 if val > 0
1792
1914
  buff << byte
1915
+ break if val == 0
1793
1916
  end
1794
1917
  end
1795
1918
 
1796
1919
  val = @leader_unit_type
1797
- if val != 0
1920
+ if has_leader_unit_type?
1798
1921
  buff << 0x10
1799
1922
 
1800
- while val != 0
1923
+ loop do
1801
1924
  byte = val & 0x7F
1802
1925
  val >>= 7
1803
1926
  byte |= 0x80 if val > 0
1804
1927
  buff << byte
1928
+ break if val == 0
1805
1929
  end
1806
1930
  end
1807
1931
 
1808
1932
  val = @count
1809
- if val != 0
1933
+ if has_count?
1810
1934
  buff << 0x18
1811
1935
 
1812
- while val != 0
1936
+ loop do
1813
1937
  byte = val & 0x7F
1814
1938
  val >>= 7
1815
1939
  byte |= 0x80 if val > 0
1816
1940
  buff << byte
1941
+ break if val == 0
1817
1942
  end
1818
1943
  end
1819
-
1944
+ buff << @_unknown_fields if @_unknown_fields
1820
1945
  buff
1821
1946
  end
1822
1947
 
1823
1948
  def to_h
1824
1949
  result = {}
1825
- result["control_group_index".to_sym] = @control_group_index
1826
- result["leader_unit_type".to_sym] = @leader_unit_type
1827
- result["count".to_sym] = @count
1950
+
1951
+ result[:"control_group_index"] = @control_group_index
1952
+ result[:"leader_unit_type"] = @leader_unit_type
1953
+ result[:"count"] = @count
1954
+
1955
+ result
1956
+ end
1957
+
1958
+ def as_json(options = {})
1959
+ result = {}
1960
+
1961
+ result["controlGroupIndex"] = @control_group_index if !options[
1962
+ :compact
1963
+ ] || has_control_group_index?
1964
+ result["leaderUnitType"] = @leader_unit_type if !options[:compact] ||
1965
+ has_leader_unit_type?
1966
+ result["count"] = @count if !options[:compact] || has_count?
1967
+
1828
1968
  result
1829
1969
  end
1970
+
1971
+ def to_json(as_json_options = {})
1972
+ require "json"
1973
+ JSON.dump(as_json(as_json_options))
1974
+ end
1830
1975
  end
1831
1976
  class UnitInfo
1832
1977
  def self.decode(buff)
@@ -2217,20 +2362,39 @@ module Api
2217
2362
  # unexpected, so discard it and continue.
2218
2363
  if !found
2219
2364
  wire_type = tag & 0x7
2365
+
2366
+ unknown_bytes = +"".b
2367
+ val = tag
2368
+ loop do
2369
+ byte = val & 0x7F
2370
+
2371
+ val >>= 7
2372
+ # This drops the top bits,
2373
+ # Otherwise, with a signed right shift,
2374
+ # we get infinity one bits at the top
2375
+ val &= (1 << 57) - 1
2376
+
2377
+ byte |= 0x80 if val != 0
2378
+ unknown_bytes << byte
2379
+ break if val == 0
2380
+ end
2381
+
2220
2382
  case wire_type
2221
2383
  when 0
2222
2384
  i = 0
2223
2385
  while true
2224
2386
  newbyte = buff.getbyte(index)
2225
2387
  index += 1
2226
- break if newbyte.nil? || newbyte < 0x80
2388
+ break if newbyte.nil?
2389
+ unknown_bytes << newbyte
2390
+ break if newbyte < 0x80
2227
2391
  i += 1
2228
2392
  break if i > 9
2229
2393
  end
2230
2394
  when 1
2395
+ unknown_bytes << buff.byteslice(index, 8)
2231
2396
  index += 8
2232
2397
  when 2
2233
- ## PULL_BYTES
2234
2398
  value =
2235
2399
  if (byte0 = buff.getbyte(index)) < 0x80
2236
2400
  index += 1
@@ -2286,15 +2450,30 @@ module Api
2286
2450
  raise "integer decoding error"
2287
2451
  end
2288
2452
 
2289
- buff.byteslice(index, value)
2290
- index += value
2453
+ val = value
2454
+ loop do
2455
+ byte = val & 0x7F
2456
+
2457
+ val >>= 7
2458
+ # This drops the top bits,
2459
+ # Otherwise, with a signed right shift,
2460
+ # we get infinity one bits at the top
2461
+ val &= (1 << 57) - 1
2462
+
2463
+ byte |= 0x80 if val != 0
2464
+ unknown_bytes << byte
2465
+ break if val == 0
2466
+ end
2291
2467
 
2292
- ## END PULL_BYTES
2468
+ unknown_bytes << buff.byteslice(index, value)
2469
+ index += value
2293
2470
  when 5
2471
+ unknown_bytes << buff.byteslice(index, 4)
2294
2472
  index += 4
2295
2473
  else
2296
2474
  raise "unknown wire type #{wire_type}"
2297
2475
  end
2476
+ (@_unknown_fields ||= +"".b) << unknown_bytes
2298
2477
  return self if index >= len
2299
2478
  ## PULL_UINT64
2300
2479
  tag =
@@ -3583,34 +3762,36 @@ module Api
3583
3762
  end
3584
3763
  def _encode(buff)
3585
3764
  val = @unit_type
3586
- if val != 0
3765
+ if has_unit_type?
3587
3766
  buff << 0x08
3588
3767
 
3589
- while val != 0
3768
+ loop do
3590
3769
  byte = val & 0x7F
3591
3770
  val >>= 7
3592
3771
  byte |= 0x80 if val > 0
3593
3772
  buff << byte
3773
+ break if val == 0
3594
3774
  end
3595
3775
  end
3596
3776
 
3597
3777
  val = @player_relative
3598
- if val != 0
3778
+ if has_player_relative?
3599
3779
  buff << 0x10
3600
3780
 
3601
- while val != 0
3781
+ loop do
3602
3782
  byte = val & 0x7F
3603
3783
  val >>= 7
3604
3784
  byte |= 0x80 if val > 0
3605
3785
  buff << byte
3786
+ break if val == 0
3606
3787
  end
3607
3788
  end
3608
3789
 
3609
3790
  val = @health
3610
- if val != 0
3791
+ if has_health?
3611
3792
  buff << 0x18
3612
3793
 
3613
- while val != 0
3794
+ loop do
3614
3795
  byte = val & 0x7F
3615
3796
 
3616
3797
  val >>= 7
@@ -3621,14 +3802,15 @@ module Api
3621
3802
 
3622
3803
  byte |= 0x80 if val != 0
3623
3804
  buff << byte
3805
+ break if val == 0
3624
3806
  end
3625
3807
  end
3626
3808
 
3627
3809
  val = @shields
3628
- if val != 0
3810
+ if has_shields?
3629
3811
  buff << 0x20
3630
3812
 
3631
- while val != 0
3813
+ loop do
3632
3814
  byte = val & 0x7F
3633
3815
 
3634
3816
  val >>= 7
@@ -3639,14 +3821,15 @@ module Api
3639
3821
 
3640
3822
  byte |= 0x80 if val != 0
3641
3823
  buff << byte
3824
+ break if val == 0
3642
3825
  end
3643
3826
  end
3644
3827
 
3645
3828
  val = @energy
3646
- if val != 0
3829
+ if has_energy?
3647
3830
  buff << 0x28
3648
3831
 
3649
- while val != 0
3832
+ loop do
3650
3833
  byte = val & 0x7F
3651
3834
 
3652
3835
  val >>= 7
@@ -3657,14 +3840,15 @@ module Api
3657
3840
 
3658
3841
  byte |= 0x80 if val != 0
3659
3842
  buff << byte
3843
+ break if val == 0
3660
3844
  end
3661
3845
  end
3662
3846
 
3663
3847
  val = @transport_slots_taken
3664
- if val != 0
3848
+ if has_transport_slots_taken?
3665
3849
  buff << 0x30
3666
3850
 
3667
- while val != 0
3851
+ loop do
3668
3852
  byte = val & 0x7F
3669
3853
 
3670
3854
  val >>= 7
@@ -3675,11 +3859,12 @@ module Api
3675
3859
 
3676
3860
  byte |= 0x80 if val != 0
3677
3861
  buff << byte
3862
+ break if val == 0
3678
3863
  end
3679
3864
  end
3680
3865
 
3681
3866
  val = @build_progress
3682
- if val != 0
3867
+ if has_build_progress?
3683
3868
  buff << 0x3d
3684
3869
 
3685
3870
  [val].pack("e", buffer: buff)
@@ -3734,10 +3919,10 @@ module Api
3734
3919
  end
3735
3920
 
3736
3921
  val = @max_health
3737
- if val != 0
3922
+ if has_max_health?
3738
3923
  buff << 0x48
3739
3924
 
3740
- while val != 0
3925
+ loop do
3741
3926
  byte = val & 0x7F
3742
3927
 
3743
3928
  val >>= 7
@@ -3748,14 +3933,15 @@ module Api
3748
3933
 
3749
3934
  byte |= 0x80 if val != 0
3750
3935
  buff << byte
3936
+ break if val == 0
3751
3937
  end
3752
3938
  end
3753
3939
 
3754
3940
  val = @max_shields
3755
- if val != 0
3941
+ if has_max_shields?
3756
3942
  buff << 0x50
3757
3943
 
3758
- while val != 0
3944
+ loop do
3759
3945
  byte = val & 0x7F
3760
3946
 
3761
3947
  val >>= 7
@@ -3766,14 +3952,15 @@ module Api
3766
3952
 
3767
3953
  byte |= 0x80 if val != 0
3768
3954
  buff << byte
3955
+ break if val == 0
3769
3956
  end
3770
3957
  end
3771
3958
 
3772
3959
  val = @max_energy
3773
- if val != 0
3960
+ if has_max_energy?
3774
3961
  buff << 0x58
3775
3962
 
3776
- while val != 0
3963
+ loop do
3777
3964
  byte = val & 0x7F
3778
3965
 
3779
3966
  val >>= 7
@@ -3784,27 +3971,64 @@ module Api
3784
3971
 
3785
3972
  byte |= 0x80 if val != 0
3786
3973
  buff << byte
3974
+ break if val == 0
3787
3975
  end
3788
3976
  end
3789
-
3977
+ buff << @_unknown_fields if @_unknown_fields
3790
3978
  buff
3791
3979
  end
3792
3980
 
3793
3981
  def to_h
3794
3982
  result = {}
3795
- result["unit_type".to_sym] = @unit_type
3796
- result["player_relative".to_sym] = @player_relative
3797
- result["health".to_sym] = @health
3798
- result["shields".to_sym] = @shields
3799
- result["energy".to_sym] = @energy
3800
- result["transport_slots_taken".to_sym] = @transport_slots_taken
3801
- result["build_progress".to_sym] = @build_progress
3802
- result["add_on".to_sym] = @add_on.to_h
3803
- result["max_health".to_sym] = @max_health
3804
- result["max_shields".to_sym] = @max_shields
3805
- result["max_energy".to_sym] = @max_energy
3983
+
3984
+ result[:"unit_type"] = @unit_type
3985
+ result[:"player_relative"] = @player_relative
3986
+ result[:"health"] = @health
3987
+ result[:"shields"] = @shields
3988
+ result[:"energy"] = @energy
3989
+ result[:"transport_slots_taken"] = @transport_slots_taken
3990
+ result[:"build_progress"] = @build_progress
3991
+ result[:"add_on"] = @add_on.to_h
3992
+ result[:"max_health"] = @max_health
3993
+ result[:"max_shields"] = @max_shields
3994
+ result[:"max_energy"] = @max_energy
3995
+
3996
+ result
3997
+ end
3998
+
3999
+ def as_json(options = {})
4000
+ result = {}
4001
+
4002
+ result["unitType"] = @unit_type if !options[:compact] || has_unit_type?
4003
+ result["playerRelative"] = @player_relative if !options[:compact] ||
4004
+ has_player_relative?
4005
+ result["health"] = @health if !options[:compact] || has_health?
4006
+ result["shields"] = @shields if !options[:compact] || has_shields?
4007
+ result["energy"] = @energy if !options[:compact] || has_energy?
4008
+ result["transportSlotsTaken"] = @transport_slots_taken if !options[
4009
+ :compact
4010
+ ] || has_transport_slots_taken?
4011
+ result["buildProgress"] = @build_progress if !options[:compact] ||
4012
+ has_build_progress?
4013
+ result["addOn"] = (
4014
+ if @add_on.nil?
4015
+ {}
4016
+ else
4017
+ @add_on.as_json(options)
4018
+ end
4019
+ ) if !options[:compact] || has_add_on?
4020
+ result["maxHealth"] = @max_health if !options[:compact] || has_max_health?
4021
+ result["maxShields"] = @max_shields if !options[:compact] ||
4022
+ has_max_shields?
4023
+ result["maxEnergy"] = @max_energy if !options[:compact] || has_max_energy?
4024
+
3806
4025
  result
3807
4026
  end
4027
+
4028
+ def to_json(as_json_options = {})
4029
+ require "json"
4030
+ JSON.dump(as_json(as_json_options))
4031
+ end
3808
4032
  end
3809
4033
  class SinglePanel
3810
4034
  def self.decode(buff)
@@ -4026,20 +4250,39 @@ module Api
4026
4250
  # unexpected, so discard it and continue.
4027
4251
  if !found
4028
4252
  wire_type = tag & 0x7
4253
+
4254
+ unknown_bytes = +"".b
4255
+ val = tag
4256
+ loop do
4257
+ byte = val & 0x7F
4258
+
4259
+ val >>= 7
4260
+ # This drops the top bits,
4261
+ # Otherwise, with a signed right shift,
4262
+ # we get infinity one bits at the top
4263
+ val &= (1 << 57) - 1
4264
+
4265
+ byte |= 0x80 if val != 0
4266
+ unknown_bytes << byte
4267
+ break if val == 0
4268
+ end
4269
+
4029
4270
  case wire_type
4030
4271
  when 0
4031
4272
  i = 0
4032
4273
  while true
4033
4274
  newbyte = buff.getbyte(index)
4034
4275
  index += 1
4035
- break if newbyte.nil? || newbyte < 0x80
4276
+ break if newbyte.nil?
4277
+ unknown_bytes << newbyte
4278
+ break if newbyte < 0x80
4036
4279
  i += 1
4037
4280
  break if i > 9
4038
4281
  end
4039
4282
  when 1
4283
+ unknown_bytes << buff.byteslice(index, 8)
4040
4284
  index += 8
4041
4285
  when 2
4042
- ## PULL_BYTES
4043
4286
  value =
4044
4287
  if (byte0 = buff.getbyte(index)) < 0x80
4045
4288
  index += 1
@@ -4095,15 +4338,30 @@ module Api
4095
4338
  raise "integer decoding error"
4096
4339
  end
4097
4340
 
4098
- buff.byteslice(index, value)
4099
- index += value
4341
+ val = value
4342
+ loop do
4343
+ byte = val & 0x7F
4344
+
4345
+ val >>= 7
4346
+ # This drops the top bits,
4347
+ # Otherwise, with a signed right shift,
4348
+ # we get infinity one bits at the top
4349
+ val &= (1 << 57) - 1
4350
+
4351
+ byte |= 0x80 if val != 0
4352
+ unknown_bytes << byte
4353
+ break if val == 0
4354
+ end
4100
4355
 
4101
- ## END PULL_BYTES
4356
+ unknown_bytes << buff.byteslice(index, value)
4357
+ index += value
4102
4358
  when 5
4359
+ unknown_bytes << buff.byteslice(index, 4)
4103
4360
  index += 4
4104
4361
  else
4105
4362
  raise "unknown wire type #{wire_type}"
4106
4363
  end
4364
+ (@_unknown_fields ||= +"".b) << unknown_bytes
4107
4365
  return self if index >= len
4108
4366
  ## PULL_UINT64
4109
4367
  tag =
@@ -4632,64 +4890,11 @@ module Api
4632
4890
 
4633
4891
  ## END PULL_UINT64
4634
4892
  end
4635
- if tag == 0x2a
4893
+ if tag == 0x28
4636
4894
  found = true
4637
- ## PULL_UINT64
4638
- value =
4639
- if (byte0 = buff.getbyte(index)) < 0x80
4640
- index += 1
4641
- byte0
4642
- elsif (byte1 = buff.getbyte(index + 1)) < 0x80
4643
- index += 2
4644
- (byte1 << 7) | (byte0 & 0x7F)
4645
- elsif (byte2 = buff.getbyte(index + 2)) < 0x80
4646
- index += 3
4647
- (byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
4648
- elsif (byte3 = buff.getbyte(index + 3)) < 0x80
4649
- index += 4
4650
- (byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
4651
- (byte0 & 0x7F)
4652
- elsif (byte4 = buff.getbyte(index + 4)) < 0x80
4653
- index += 5
4654
- (byte4 << 28) | ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
4655
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
4656
- elsif (byte5 = buff.getbyte(index + 5)) < 0x80
4657
- index += 6
4658
- (byte5 << 35) | ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
4659
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
4660
- elsif (byte6 = buff.getbyte(index + 6)) < 0x80
4661
- index += 7
4662
- (byte6 << 42) | ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
4663
- ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
4664
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
4665
- elsif (byte7 = buff.getbyte(index + 7)) < 0x80
4666
- index += 8
4667
- (byte7 << 49) | ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
4668
- ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
4669
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
4670
- elsif (byte8 = buff.getbyte(index + 8)) < 0x80
4671
- index += 9
4672
- (byte8 << 56) | ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
4673
- ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
4674
- ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
4675
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
4676
- elsif (byte9 = buff.getbyte(index + 9)) < 0x80
4677
- index += 10
4678
-
4679
- (byte9 << 63) | ((byte8 & 0x7F) << 56) | ((byte7 & 0x7F) << 49) |
4680
- ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
4681
- ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
4682
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
4683
- else
4684
- raise "integer decoding error"
4685
- end
4686
-
4687
- ## END PULL_UINT64
4688
-
4689
- goal = index + value
4895
+ ## DECODE REPEATED
4690
4896
  list = @buffs
4691
4897
  while true
4692
- break if index >= goal
4693
4898
  ## PULL_INT32
4694
4899
  list << if (byte0 = buff.getbyte(index)) < 0x80
4695
4900
  index += 1
@@ -4752,60 +4957,71 @@ module Api
4752
4957
  end
4753
4958
 
4754
4959
  ## END PULL_INT32
4960
+
4961
+ return self if index >= len
4962
+ ## PULL_UINT64
4963
+ tag =
4964
+ if (byte0 = buff.getbyte(index)) < 0x80
4965
+ index += 1
4966
+ byte0
4967
+ elsif (byte1 = buff.getbyte(index + 1)) < 0x80
4968
+ index += 2
4969
+ (byte1 << 7) | (byte0 & 0x7F)
4970
+ elsif (byte2 = buff.getbyte(index + 2)) < 0x80
4971
+ index += 3
4972
+ (byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
4973
+ elsif (byte3 = buff.getbyte(index + 3)) < 0x80
4974
+ index += 4
4975
+ (byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
4976
+ (byte0 & 0x7F)
4977
+ elsif (byte4 = buff.getbyte(index + 4)) < 0x80
4978
+ index += 5
4979
+ (byte4 << 28) | ((byte3 & 0x7F) << 21) |
4980
+ ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
4981
+ (byte0 & 0x7F)
4982
+ elsif (byte5 = buff.getbyte(index + 5)) < 0x80
4983
+ index += 6
4984
+ (byte5 << 35) | ((byte4 & 0x7F) << 28) |
4985
+ ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
4986
+ ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
4987
+ elsif (byte6 = buff.getbyte(index + 6)) < 0x80
4988
+ index += 7
4989
+ (byte6 << 42) | ((byte5 & 0x7F) << 35) |
4990
+ ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
4991
+ ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
4992
+ (byte0 & 0x7F)
4993
+ elsif (byte7 = buff.getbyte(index + 7)) < 0x80
4994
+ index += 8
4995
+ (byte7 << 49) | ((byte6 & 0x7F) << 42) |
4996
+ ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
4997
+ ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
4998
+ ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
4999
+ elsif (byte8 = buff.getbyte(index + 8)) < 0x80
5000
+ index += 9
5001
+ (byte8 << 56) | ((byte7 & 0x7F) << 49) |
5002
+ ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
5003
+ ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
5004
+ ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
5005
+ (byte0 & 0x7F)
5006
+ elsif (byte9 = buff.getbyte(index + 9)) < 0x80
5007
+ index += 10
5008
+
5009
+ (byte9 << 63) | ((byte8 & 0x7F) << 56) |
5010
+ ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
5011
+ ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
5012
+ ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
5013
+ ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
5014
+ else
5015
+ raise "integer decoding error"
5016
+ end
5017
+
5018
+ ## END PULL_UINT64
5019
+
5020
+ break unless tag == 0x28
4755
5021
  end
5022
+ ## END DECODE REPEATED
4756
5023
 
4757
5024
  return self if index >= len
4758
- ## PULL_UINT64
4759
- tag =
4760
- if (byte0 = buff.getbyte(index)) < 0x80
4761
- index += 1
4762
- byte0
4763
- elsif (byte1 = buff.getbyte(index + 1)) < 0x80
4764
- index += 2
4765
- (byte1 << 7) | (byte0 & 0x7F)
4766
- elsif (byte2 = buff.getbyte(index + 2)) < 0x80
4767
- index += 3
4768
- (byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
4769
- elsif (byte3 = buff.getbyte(index + 3)) < 0x80
4770
- index += 4
4771
- (byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
4772
- (byte0 & 0x7F)
4773
- elsif (byte4 = buff.getbyte(index + 4)) < 0x80
4774
- index += 5
4775
- (byte4 << 28) | ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
4776
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
4777
- elsif (byte5 = buff.getbyte(index + 5)) < 0x80
4778
- index += 6
4779
- (byte5 << 35) | ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
4780
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
4781
- elsif (byte6 = buff.getbyte(index + 6)) < 0x80
4782
- index += 7
4783
- (byte6 << 42) | ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
4784
- ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
4785
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
4786
- elsif (byte7 = buff.getbyte(index + 7)) < 0x80
4787
- index += 8
4788
- (byte7 << 49) | ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
4789
- ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
4790
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
4791
- elsif (byte8 = buff.getbyte(index + 8)) < 0x80
4792
- index += 9
4793
- (byte8 << 56) | ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
4794
- ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
4795
- ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
4796
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
4797
- elsif (byte9 = buff.getbyte(index + 9)) < 0x80
4798
- index += 10
4799
-
4800
- (byte9 << 63) | ((byte8 & 0x7F) << 56) | ((byte7 & 0x7F) << 49) |
4801
- ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
4802
- ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
4803
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
4804
- else
4805
- raise "integer decoding error"
4806
- end
4807
-
4808
- ## END PULL_UINT64
4809
5025
  end
4810
5026
 
4811
5027
  return self if index >= len
@@ -4861,10 +5077,10 @@ module Api
4861
5077
  end
4862
5078
 
4863
5079
  val = @attack_upgrade_level
4864
- if val != 0
5080
+ if has_attack_upgrade_level?
4865
5081
  buff << 0x10
4866
5082
 
4867
- while val != 0
5083
+ loop do
4868
5084
  byte = val & 0x7F
4869
5085
 
4870
5086
  val >>= 7
@@ -4875,14 +5091,15 @@ module Api
4875
5091
 
4876
5092
  byte |= 0x80 if val != 0
4877
5093
  buff << byte
5094
+ break if val == 0
4878
5095
  end
4879
5096
  end
4880
5097
 
4881
5098
  val = @armor_upgrade_level
4882
- if val != 0
5099
+ if has_armor_upgrade_level?
4883
5100
  buff << 0x18
4884
5101
 
4885
- while val != 0
5102
+ loop do
4886
5103
  byte = val & 0x7F
4887
5104
 
4888
5105
  val >>= 7
@@ -4893,14 +5110,15 @@ module Api
4893
5110
 
4894
5111
  byte |= 0x80 if val != 0
4895
5112
  buff << byte
5113
+ break if val == 0
4896
5114
  end
4897
5115
  end
4898
5116
 
4899
5117
  val = @shield_upgrade_level
4900
- if val != 0
5118
+ if has_shield_upgrade_level?
4901
5119
  buff << 0x20
4902
5120
 
4903
- while val != 0
5121
+ loop do
4904
5122
  byte = val & 0x7F
4905
5123
 
4906
5124
  val >>= 7
@@ -4911,24 +5129,18 @@ module Api
4911
5129
 
4912
5130
  byte |= 0x80 if val != 0
4913
5131
  buff << byte
5132
+ break if val == 0
4914
5133
  end
4915
5134
  end
4916
5135
 
4917
5136
  list = @buffs
4918
5137
  if list.size > 0
4919
- buff << 0x2a
4920
-
4921
- # Save the buffer size before appending the repeated bytes
4922
- current_len = buff.bytesize
4923
-
4924
- # Write a single dummy byte to later store encoded length
4925
- buff << 42 # "*"
4926
-
4927
- # write each item
4928
5138
  list.each do |item|
4929
5139
  val = item
4930
5140
  if val != 0
4931
- while val != 0
5141
+ buff << 0x28
5142
+
5143
+ loop do
4932
5144
  byte = val & 0x7F
4933
5145
 
4934
5146
  val >>= 7
@@ -4939,56 +5151,52 @@ module Api
4939
5151
 
4940
5152
  byte |= 0x80 if val != 0
4941
5153
  buff << byte
5154
+ break if val == 0
4942
5155
  end
4943
5156
  end
4944
5157
  end
5158
+ end
5159
+ buff << @_unknown_fields if @_unknown_fields
5160
+ buff
5161
+ end
4945
5162
 
4946
- # Calculate the submessage's size
4947
- submessage_size = buff.bytesize - current_len - 1
4948
-
4949
- # Hope the size fits in one byte
4950
- byte = submessage_size & 0x7F
4951
- submessage_size >>= 7
4952
- byte |= 0x80 if submessage_size > 0
4953
- buff.setbyte(current_len, byte)
5163
+ def to_h
5164
+ result = {}
4954
5165
 
4955
- # If the sub message was bigger
4956
- if submessage_size > 0
4957
- current_len += 1
5166
+ result[:"unit"] = @unit.to_h
5167
+ result[:"attack_upgrade_level"] = @attack_upgrade_level
5168
+ result[:"armor_upgrade_level"] = @armor_upgrade_level
5169
+ result[:"shield_upgrade_level"] = @shield_upgrade_level
5170
+ result[:"buffs"] = @buffs
4958
5171
 
4959
- # compute how much we need to shift
4960
- encoded_int_len = 0
4961
- remaining_size = submessage_size
4962
- while remaining_size != 0
4963
- remaining_size >>= 7
4964
- encoded_int_len += 1
4965
- end
5172
+ result
5173
+ end
4966
5174
 
4967
- # Make space in the string with dummy bytes
4968
- buff.bytesplice(current_len, 0, "*********", 0, encoded_int_len)
5175
+ def as_json(options = {})
5176
+ result = {}
4969
5177
 
4970
- # Overwrite the dummy bytes with the encoded length
4971
- while submessage_size != 0
4972
- byte = submessage_size & 0x7F
4973
- submessage_size >>= 7
4974
- byte |= 0x80 if submessage_size > 0
4975
- buff.setbyte(current_len, byte)
4976
- current_len += 1
4977
- end
4978
- end
4979
- end
5178
+ result["unit"] = @unit.nil? ? {} : @unit.as_json(options) if !options[
5179
+ :compact
5180
+ ] || has_unit?
5181
+ result["attackUpgradeLevel"] = @attack_upgrade_level if !options[
5182
+ :compact
5183
+ ] || has_attack_upgrade_level?
5184
+ result["armorUpgradeLevel"] = @armor_upgrade_level if !options[
5185
+ :compact
5186
+ ] || has_armor_upgrade_level?
5187
+ result["shieldUpgradeLevel"] = @shield_upgrade_level if !options[
5188
+ :compact
5189
+ ] || has_shield_upgrade_level?
5190
+ tmp_buffs = @buffs
5191
+
5192
+ result["buffs"] = tmp_buffs if !options[:compact] || tmp_buffs.any?
4980
5193
 
4981
- buff
5194
+ result
4982
5195
  end
4983
5196
 
4984
- def to_h
4985
- result = {}
4986
- result["unit".to_sym] = @unit.to_h
4987
- result["attack_upgrade_level".to_sym] = @attack_upgrade_level
4988
- result["armor_upgrade_level".to_sym] = @armor_upgrade_level
4989
- result["shield_upgrade_level".to_sym] = @shield_upgrade_level
4990
- result["buffs".to_sym] = @buffs
4991
- result
5197
+ def to_json(as_json_options = {})
5198
+ require "json"
5199
+ JSON.dump(as_json(as_json_options))
4992
5200
  end
4993
5201
  end
4994
5202
  class MultiPanel
@@ -5077,20 +5285,39 @@ module Api
5077
5285
  # unexpected, so discard it and continue.
5078
5286
  if !found
5079
5287
  wire_type = tag & 0x7
5288
+
5289
+ unknown_bytes = +"".b
5290
+ val = tag
5291
+ loop do
5292
+ byte = val & 0x7F
5293
+
5294
+ val >>= 7
5295
+ # This drops the top bits,
5296
+ # Otherwise, with a signed right shift,
5297
+ # we get infinity one bits at the top
5298
+ val &= (1 << 57) - 1
5299
+
5300
+ byte |= 0x80 if val != 0
5301
+ unknown_bytes << byte
5302
+ break if val == 0
5303
+ end
5304
+
5080
5305
  case wire_type
5081
5306
  when 0
5082
5307
  i = 0
5083
5308
  while true
5084
5309
  newbyte = buff.getbyte(index)
5085
5310
  index += 1
5086
- break if newbyte.nil? || newbyte < 0x80
5311
+ break if newbyte.nil?
5312
+ unknown_bytes << newbyte
5313
+ break if newbyte < 0x80
5087
5314
  i += 1
5088
5315
  break if i > 9
5089
5316
  end
5090
5317
  when 1
5318
+ unknown_bytes << buff.byteslice(index, 8)
5091
5319
  index += 8
5092
5320
  when 2
5093
- ## PULL_BYTES
5094
5321
  value =
5095
5322
  if (byte0 = buff.getbyte(index)) < 0x80
5096
5323
  index += 1
@@ -5146,15 +5373,30 @@ module Api
5146
5373
  raise "integer decoding error"
5147
5374
  end
5148
5375
 
5149
- buff.byteslice(index, value)
5150
- index += value
5376
+ val = value
5377
+ loop do
5378
+ byte = val & 0x7F
5379
+
5380
+ val >>= 7
5381
+ # This drops the top bits,
5382
+ # Otherwise, with a signed right shift,
5383
+ # we get infinity one bits at the top
5384
+ val &= (1 << 57) - 1
5385
+
5386
+ byte |= 0x80 if val != 0
5387
+ unknown_bytes << byte
5388
+ break if val == 0
5389
+ end
5151
5390
 
5152
- ## END PULL_BYTES
5391
+ unknown_bytes << buff.byteslice(index, value)
5392
+ index += value
5153
5393
  when 5
5394
+ unknown_bytes << buff.byteslice(index, 4)
5154
5395
  index += 4
5155
5396
  else
5156
5397
  raise "unknown wire type #{wire_type}"
5157
5398
  end
5399
+ (@_unknown_fields ||= +"".b) << unknown_bytes
5158
5400
  return self if index >= len
5159
5401
  ## PULL_UINT64
5160
5402
  tag =
@@ -5403,15 +5645,32 @@ module Api
5403
5645
  end
5404
5646
  end
5405
5647
  end
5406
-
5648
+ buff << @_unknown_fields if @_unknown_fields
5407
5649
  buff
5408
5650
  end
5409
5651
 
5410
5652
  def to_h
5411
5653
  result = {}
5412
- result["units".to_sym] = @units
5654
+
5655
+ result[:"units"] = @units.map(&:to_h)
5656
+
5657
+ result
5658
+ end
5659
+
5660
+ def as_json(options = {})
5661
+ result = {}
5662
+
5663
+ tmp_units = @units.map { |v| v.as_json(options) }
5664
+
5665
+ result["units"] = tmp_units if !options[:compact] || tmp_units.any?
5666
+
5413
5667
  result
5414
5668
  end
5669
+
5670
+ def to_json(as_json_options = {})
5671
+ require "json"
5672
+ JSON.dump(as_json(as_json_options))
5673
+ end
5415
5674
  end
5416
5675
  class CargoPanel
5417
5676
  def self.decode(buff)
@@ -5556,20 +5815,39 @@ module Api
5556
5815
  # unexpected, so discard it and continue.
5557
5816
  if !found
5558
5817
  wire_type = tag & 0x7
5818
+
5819
+ unknown_bytes = +"".b
5820
+ val = tag
5821
+ loop do
5822
+ byte = val & 0x7F
5823
+
5824
+ val >>= 7
5825
+ # This drops the top bits,
5826
+ # Otherwise, with a signed right shift,
5827
+ # we get infinity one bits at the top
5828
+ val &= (1 << 57) - 1
5829
+
5830
+ byte |= 0x80 if val != 0
5831
+ unknown_bytes << byte
5832
+ break if val == 0
5833
+ end
5834
+
5559
5835
  case wire_type
5560
5836
  when 0
5561
5837
  i = 0
5562
5838
  while true
5563
5839
  newbyte = buff.getbyte(index)
5564
5840
  index += 1
5565
- break if newbyte.nil? || newbyte < 0x80
5841
+ break if newbyte.nil?
5842
+ unknown_bytes << newbyte
5843
+ break if newbyte < 0x80
5566
5844
  i += 1
5567
5845
  break if i > 9
5568
5846
  end
5569
5847
  when 1
5848
+ unknown_bytes << buff.byteslice(index, 8)
5570
5849
  index += 8
5571
5850
  when 2
5572
- ## PULL_BYTES
5573
5851
  value =
5574
5852
  if (byte0 = buff.getbyte(index)) < 0x80
5575
5853
  index += 1
@@ -5625,15 +5903,30 @@ module Api
5625
5903
  raise "integer decoding error"
5626
5904
  end
5627
5905
 
5628
- buff.byteslice(index, value)
5629
- index += value
5906
+ val = value
5907
+ loop do
5908
+ byte = val & 0x7F
5630
5909
 
5631
- ## END PULL_BYTES
5910
+ val >>= 7
5911
+ # This drops the top bits,
5912
+ # Otherwise, with a signed right shift,
5913
+ # we get infinity one bits at the top
5914
+ val &= (1 << 57) - 1
5915
+
5916
+ byte |= 0x80 if val != 0
5917
+ unknown_bytes << byte
5918
+ break if val == 0
5919
+ end
5920
+
5921
+ unknown_bytes << buff.byteslice(index, value)
5922
+ index += value
5632
5923
  when 5
5924
+ unknown_bytes << buff.byteslice(index, 4)
5633
5925
  index += 4
5634
5926
  else
5635
5927
  raise "unknown wire type #{wire_type}"
5636
5928
  end
5929
+ (@_unknown_fields ||= +"".b) << unknown_bytes
5637
5930
  return self if index >= len
5638
5931
  ## PULL_UINT64
5639
5932
  tag =
@@ -6165,10 +6458,10 @@ module Api
6165
6458
  end
6166
6459
 
6167
6460
  val = @slots_available
6168
- if val != 0
6461
+ if has_slots_available?
6169
6462
  buff << 0x18
6170
6463
 
6171
- while val != 0
6464
+ loop do
6172
6465
  byte = val & 0x7F
6173
6466
 
6174
6467
  val >>= 7
@@ -6179,19 +6472,44 @@ module Api
6179
6472
 
6180
6473
  byte |= 0x80 if val != 0
6181
6474
  buff << byte
6475
+ break if val == 0
6182
6476
  end
6183
6477
  end
6184
-
6478
+ buff << @_unknown_fields if @_unknown_fields
6185
6479
  buff
6186
6480
  end
6187
6481
 
6188
6482
  def to_h
6189
6483
  result = {}
6190
- result["unit".to_sym] = @unit.to_h
6191
- result["passengers".to_sym] = @passengers
6192
- result["slots_available".to_sym] = @slots_available
6484
+
6485
+ result[:"unit"] = @unit.to_h
6486
+ result[:"passengers"] = @passengers.map(&:to_h)
6487
+ result[:"slots_available"] = @slots_available
6488
+
6489
+ result
6490
+ end
6491
+
6492
+ def as_json(options = {})
6493
+ result = {}
6494
+
6495
+ result["unit"] = @unit.nil? ? {} : @unit.as_json(options) if !options[
6496
+ :compact
6497
+ ] || has_unit?
6498
+ tmp_passengers = @passengers.map { |v| v.as_json(options) }
6499
+
6500
+ result["passengers"] = tmp_passengers if !options[:compact] ||
6501
+ tmp_passengers.any?
6502
+
6503
+ result["slotsAvailable"] = @slots_available if !options[:compact] ||
6504
+ has_slots_available?
6505
+
6193
6506
  result
6194
6507
  end
6508
+
6509
+ def to_json(as_json_options = {})
6510
+ require "json"
6511
+ JSON.dump(as_json(as_json_options))
6512
+ end
6195
6513
  end
6196
6514
  class BuildItem
6197
6515
  def self.decode(buff)
@@ -6326,20 +6644,39 @@ module Api
6326
6644
  # unexpected, so discard it and continue.
6327
6645
  if !found
6328
6646
  wire_type = tag & 0x7
6647
+
6648
+ unknown_bytes = +"".b
6649
+ val = tag
6650
+ loop do
6651
+ byte = val & 0x7F
6652
+
6653
+ val >>= 7
6654
+ # This drops the top bits,
6655
+ # Otherwise, with a signed right shift,
6656
+ # we get infinity one bits at the top
6657
+ val &= (1 << 57) - 1
6658
+
6659
+ byte |= 0x80 if val != 0
6660
+ unknown_bytes << byte
6661
+ break if val == 0
6662
+ end
6663
+
6329
6664
  case wire_type
6330
6665
  when 0
6331
6666
  i = 0
6332
6667
  while true
6333
6668
  newbyte = buff.getbyte(index)
6334
6669
  index += 1
6335
- break if newbyte.nil? || newbyte < 0x80
6670
+ break if newbyte.nil?
6671
+ unknown_bytes << newbyte
6672
+ break if newbyte < 0x80
6336
6673
  i += 1
6337
6674
  break if i > 9
6338
6675
  end
6339
6676
  when 1
6677
+ unknown_bytes << buff.byteslice(index, 8)
6340
6678
  index += 8
6341
6679
  when 2
6342
- ## PULL_BYTES
6343
6680
  value =
6344
6681
  if (byte0 = buff.getbyte(index)) < 0x80
6345
6682
  index += 1
@@ -6395,15 +6732,30 @@ module Api
6395
6732
  raise "integer decoding error"
6396
6733
  end
6397
6734
 
6398
- buff.byteslice(index, value)
6399
- index += value
6735
+ val = value
6736
+ loop do
6737
+ byte = val & 0x7F
6738
+
6739
+ val >>= 7
6740
+ # This drops the top bits,
6741
+ # Otherwise, with a signed right shift,
6742
+ # we get infinity one bits at the top
6743
+ val &= (1 << 57) - 1
6400
6744
 
6401
- ## END PULL_BYTES
6745
+ byte |= 0x80 if val != 0
6746
+ unknown_bytes << byte
6747
+ break if val == 0
6748
+ end
6749
+
6750
+ unknown_bytes << buff.byteslice(index, value)
6751
+ index += value
6402
6752
  when 5
6753
+ unknown_bytes << buff.byteslice(index, 4)
6403
6754
  index += 4
6404
6755
  else
6405
6756
  raise "unknown wire type #{wire_type}"
6406
6757
  end
6758
+ (@_unknown_fields ||= +"".b) << unknown_bytes
6407
6759
  return self if index >= len
6408
6760
  ## PULL_UINT64
6409
6761
  tag =
@@ -6631,33 +6983,51 @@ module Api
6631
6983
  end
6632
6984
  def _encode(buff)
6633
6985
  val = @ability_id
6634
- if val != 0
6986
+ if has_ability_id?
6635
6987
  buff << 0x08
6636
6988
 
6637
- while val != 0
6989
+ loop do
6638
6990
  byte = val & 0x7F
6639
6991
  val >>= 7
6640
6992
  byte |= 0x80 if val > 0
6641
6993
  buff << byte
6994
+ break if val == 0
6642
6995
  end
6643
6996
  end
6644
6997
 
6645
6998
  val = @build_progress
6646
- if val != 0
6999
+ if has_build_progress?
6647
7000
  buff << 0x15
6648
7001
 
6649
7002
  [val].pack("e", buffer: buff)
6650
7003
  end
6651
-
7004
+ buff << @_unknown_fields if @_unknown_fields
6652
7005
  buff
6653
7006
  end
6654
7007
 
6655
7008
  def to_h
6656
7009
  result = {}
6657
- result["ability_id".to_sym] = @ability_id
6658
- result["build_progress".to_sym] = @build_progress
7010
+
7011
+ result[:"ability_id"] = @ability_id
7012
+ result[:"build_progress"] = @build_progress
7013
+
7014
+ result
7015
+ end
7016
+
7017
+ def as_json(options = {})
7018
+ result = {}
7019
+
7020
+ result["abilityId"] = @ability_id if !options[:compact] || has_ability_id?
7021
+ result["buildProgress"] = @build_progress if !options[:compact] ||
7022
+ has_build_progress?
7023
+
6659
7024
  result
6660
7025
  end
7026
+
7027
+ def to_json(as_json_options = {})
7028
+ require "json"
7029
+ JSON.dump(as_json(as_json_options))
7030
+ end
6661
7031
  end
6662
7032
  class ProductionPanel
6663
7033
  def self.decode(buff)
@@ -6782,20 +7152,39 @@ module Api
6782
7152
  # unexpected, so discard it and continue.
6783
7153
  if !found
6784
7154
  wire_type = tag & 0x7
7155
+
7156
+ unknown_bytes = +"".b
7157
+ val = tag
7158
+ loop do
7159
+ byte = val & 0x7F
7160
+
7161
+ val >>= 7
7162
+ # This drops the top bits,
7163
+ # Otherwise, with a signed right shift,
7164
+ # we get infinity one bits at the top
7165
+ val &= (1 << 57) - 1
7166
+
7167
+ byte |= 0x80 if val != 0
7168
+ unknown_bytes << byte
7169
+ break if val == 0
7170
+ end
7171
+
6785
7172
  case wire_type
6786
7173
  when 0
6787
7174
  i = 0
6788
7175
  while true
6789
7176
  newbyte = buff.getbyte(index)
6790
7177
  index += 1
6791
- break if newbyte.nil? || newbyte < 0x80
7178
+ break if newbyte.nil?
7179
+ unknown_bytes << newbyte
7180
+ break if newbyte < 0x80
6792
7181
  i += 1
6793
7182
  break if i > 9
6794
7183
  end
6795
7184
  when 1
7185
+ unknown_bytes << buff.byteslice(index, 8)
6796
7186
  index += 8
6797
7187
  when 2
6798
- ## PULL_BYTES
6799
7188
  value =
6800
7189
  if (byte0 = buff.getbyte(index)) < 0x80
6801
7190
  index += 1
@@ -6851,15 +7240,30 @@ module Api
6851
7240
  raise "integer decoding error"
6852
7241
  end
6853
7242
 
6854
- buff.byteslice(index, value)
6855
- index += value
7243
+ val = value
7244
+ loop do
7245
+ byte = val & 0x7F
7246
+
7247
+ val >>= 7
7248
+ # This drops the top bits,
7249
+ # Otherwise, with a signed right shift,
7250
+ # we get infinity one bits at the top
7251
+ val &= (1 << 57) - 1
6856
7252
 
6857
- ## END PULL_BYTES
7253
+ byte |= 0x80 if val != 0
7254
+ unknown_bytes << byte
7255
+ break if val == 0
7256
+ end
7257
+
7258
+ unknown_bytes << buff.byteslice(index, value)
7259
+ index += value
6858
7260
  when 5
7261
+ unknown_bytes << buff.byteslice(index, 4)
6859
7262
  index += 4
6860
7263
  else
6861
7264
  raise "unknown wire type #{wire_type}"
6862
7265
  end
7266
+ (@_unknown_fields ||= +"".b) << unknown_bytes
6863
7267
  return self if index >= len
6864
7268
  ## PULL_UINT64
6865
7269
  tag =
@@ -7458,17 +7862,43 @@ module Api
7458
7862
  end
7459
7863
  end
7460
7864
  end
7461
-
7865
+ buff << @_unknown_fields if @_unknown_fields
7462
7866
  buff
7463
7867
  end
7464
7868
 
7465
7869
  def to_h
7466
7870
  result = {}
7467
- result["unit".to_sym] = @unit.to_h
7468
- result["build_queue".to_sym] = @build_queue
7469
- result["production_queue".to_sym] = @production_queue
7871
+
7872
+ result[:"unit"] = @unit.to_h
7873
+ result[:"build_queue"] = @build_queue.map(&:to_h)
7874
+ result[:"production_queue"] = @production_queue.map(&:to_h)
7875
+
7876
+ result
7877
+ end
7878
+
7879
+ def as_json(options = {})
7880
+ result = {}
7881
+
7882
+ result["unit"] = @unit.nil? ? {} : @unit.as_json(options) if !options[
7883
+ :compact
7884
+ ] || has_unit?
7885
+ tmp_build_queue = @build_queue.map { |v| v.as_json(options) }
7886
+
7887
+ result["buildQueue"] = tmp_build_queue if !options[:compact] ||
7888
+ tmp_build_queue.any?
7889
+
7890
+ tmp_production_queue = @production_queue.map { |v| v.as_json(options) }
7891
+
7892
+ result["productionQueue"] = tmp_production_queue if !options[:compact] ||
7893
+ tmp_production_queue.any?
7894
+
7470
7895
  result
7471
7896
  end
7897
+
7898
+ def to_json(as_json_options = {})
7899
+ require "json"
7900
+ JSON.dump(as_json(as_json_options))
7901
+ end
7472
7902
  end
7473
7903
  class ActionUI
7474
7904
  def self.decode(buff)
@@ -7700,20 +8130,39 @@ module Api
7700
8130
  # unexpected, so discard it and continue.
7701
8131
  if !found
7702
8132
  wire_type = tag & 0x7
8133
+
8134
+ unknown_bytes = +"".b
8135
+ val = tag
8136
+ loop do
8137
+ byte = val & 0x7F
8138
+
8139
+ val >>= 7
8140
+ # This drops the top bits,
8141
+ # Otherwise, with a signed right shift,
8142
+ # we get infinity one bits at the top
8143
+ val &= (1 << 57) - 1
8144
+
8145
+ byte |= 0x80 if val != 0
8146
+ unknown_bytes << byte
8147
+ break if val == 0
8148
+ end
8149
+
7703
8150
  case wire_type
7704
8151
  when 0
7705
8152
  i = 0
7706
8153
  while true
7707
8154
  newbyte = buff.getbyte(index)
7708
8155
  index += 1
7709
- break if newbyte.nil? || newbyte < 0x80
8156
+ break if newbyte.nil?
8157
+ unknown_bytes << newbyte
8158
+ break if newbyte < 0x80
7710
8159
  i += 1
7711
8160
  break if i > 9
7712
8161
  end
7713
8162
  when 1
8163
+ unknown_bytes << buff.byteslice(index, 8)
7714
8164
  index += 8
7715
8165
  when 2
7716
- ## PULL_BYTES
7717
8166
  value =
7718
8167
  if (byte0 = buff.getbyte(index)) < 0x80
7719
8168
  index += 1
@@ -7769,15 +8218,30 @@ module Api
7769
8218
  raise "integer decoding error"
7770
8219
  end
7771
8220
 
7772
- buff.byteslice(index, value)
7773
- index += value
8221
+ val = value
8222
+ loop do
8223
+ byte = val & 0x7F
8224
+
8225
+ val >>= 7
8226
+ # This drops the top bits,
8227
+ # Otherwise, with a signed right shift,
8228
+ # we get infinity one bits at the top
8229
+ val &= (1 << 57) - 1
8230
+
8231
+ byte |= 0x80 if val != 0
8232
+ unknown_bytes << byte
8233
+ break if val == 0
8234
+ end
7774
8235
 
7775
- ## END PULL_BYTES
8236
+ unknown_bytes << buff.byteslice(index, value)
8237
+ index += value
7776
8238
  when 5
8239
+ unknown_bytes << buff.byteslice(index, 4)
7777
8240
  index += 4
7778
8241
  else
7779
8242
  raise "unknown wire type #{wire_type}"
7780
8243
  end
8244
+ (@_unknown_fields ||= +"".b) << unknown_bytes
7781
8245
  return self if index >= len
7782
8246
  ## PULL_UINT64
7783
8247
  tag =
@@ -9322,15 +9786,115 @@ module Api
9322
9786
 
9323
9787
  buff
9324
9788
  end
9325
-
9789
+ buff << @_unknown_fields if @_unknown_fields
9326
9790
  buff
9327
9791
  end
9328
9792
 
9329
9793
  def to_h
9330
9794
  result = {}
9331
- send("action").tap { |f| result[f.to_sym] = send(f) if f }
9795
+
9796
+ resolved_action = self.action
9797
+
9798
+ result[:"control_group"] = @control_group.to_h if resolved_action ==
9799
+ :"control_group"
9800
+ result[:"select_army"] = @select_army.to_h if resolved_action ==
9801
+ :"select_army"
9802
+ result[
9803
+ :"select_warp_gates"
9804
+ ] = @select_warp_gates.to_h if resolved_action == :"select_warp_gates"
9805
+ result[:"select_larva"] = @select_larva.to_h if resolved_action ==
9806
+ :"select_larva"
9807
+ result[
9808
+ :"select_idle_worker"
9809
+ ] = @select_idle_worker.to_h if resolved_action == :"select_idle_worker"
9810
+ result[:"multi_panel"] = @multi_panel.to_h if resolved_action ==
9811
+ :"multi_panel"
9812
+ result[:"cargo_panel"] = @cargo_panel.to_h if resolved_action ==
9813
+ :"cargo_panel"
9814
+ result[:"production_panel"] = @production_panel.to_h if resolved_action ==
9815
+ :"production_panel"
9816
+ result[:"toggle_autocast"] = @toggle_autocast.to_h if resolved_action ==
9817
+ :"toggle_autocast"
9818
+
9819
+ result
9820
+ end
9821
+
9822
+ def as_json(options = {})
9823
+ result = {}
9824
+
9825
+ resolved_action = self.action
9826
+
9827
+ result["controlGroup"] = (
9828
+ if @control_group.nil?
9829
+ {}
9830
+ else
9831
+ @control_group.as_json(options)
9832
+ end
9833
+ ) if resolved_action == :"control_group"
9834
+ result["selectArmy"] = (
9835
+ if @select_army.nil?
9836
+ {}
9837
+ else
9838
+ @select_army.as_json(options)
9839
+ end
9840
+ ) if resolved_action == :"select_army"
9841
+ result["selectWarpGates"] = (
9842
+ if @select_warp_gates.nil?
9843
+ {}
9844
+ else
9845
+ @select_warp_gates.as_json(options)
9846
+ end
9847
+ ) if resolved_action == :"select_warp_gates"
9848
+ result["selectLarva"] = (
9849
+ if @select_larva.nil?
9850
+ {}
9851
+ else
9852
+ @select_larva.as_json(options)
9853
+ end
9854
+ ) if resolved_action == :"select_larva"
9855
+ result["selectIdleWorker"] = (
9856
+ if @select_idle_worker.nil?
9857
+ {}
9858
+ else
9859
+ @select_idle_worker.as_json(options)
9860
+ end
9861
+ ) if resolved_action == :"select_idle_worker"
9862
+ result["multiPanel"] = (
9863
+ if @multi_panel.nil?
9864
+ {}
9865
+ else
9866
+ @multi_panel.as_json(options)
9867
+ end
9868
+ ) if resolved_action == :"multi_panel"
9869
+ result["cargoPanel"] = (
9870
+ if @cargo_panel.nil?
9871
+ {}
9872
+ else
9873
+ @cargo_panel.as_json(options)
9874
+ end
9875
+ ) if resolved_action == :"cargo_panel"
9876
+ result["productionPanel"] = (
9877
+ if @production_panel.nil?
9878
+ {}
9879
+ else
9880
+ @production_panel.as_json(options)
9881
+ end
9882
+ ) if resolved_action == :"production_panel"
9883
+ result["toggleAutocast"] = (
9884
+ if @toggle_autocast.nil?
9885
+ {}
9886
+ else
9887
+ @toggle_autocast.as_json(options)
9888
+ end
9889
+ ) if resolved_action == :"toggle_autocast"
9890
+
9332
9891
  result
9333
9892
  end
9893
+
9894
+ def to_json(as_json_options = {})
9895
+ require "json"
9896
+ JSON.dump(as_json(as_json_options))
9897
+ end
9334
9898
  end
9335
9899
  class ActionControlGroup
9336
9900
  def self.decode(buff)
@@ -9349,35 +9913,21 @@ module Api
9349
9913
  APPEND_AND_STEAL = 5
9350
9914
 
9351
9915
  def self.lookup(val)
9352
- if val == 0
9353
- :ENUM_CONTROL_GROUP_ACTION_UNSET
9354
- elsif val == 1
9355
- :RECALL
9356
- elsif val == 2
9357
- :SET
9358
- elsif val == 3
9359
- :APPEND
9360
- elsif val == 4
9361
- :SET_AND_STEAL
9362
- elsif val == 5
9363
- :APPEND_AND_STEAL
9364
- end
9916
+ return :ENUM_CONTROL_GROUP_ACTION_UNSET if val == 0
9917
+ return :RECALL if val == 1
9918
+ return :SET if val == 2
9919
+ return :APPEND if val == 3
9920
+ return :SET_AND_STEAL if val == 4
9921
+ return :APPEND_AND_STEAL if val == 5
9365
9922
  end
9366
9923
 
9367
9924
  def self.resolve(val)
9368
- if val == :ENUM_CONTROL_GROUP_ACTION_UNSET
9369
- 0
9370
- elsif val == :RECALL
9371
- 1
9372
- elsif val == :SET
9373
- 2
9374
- elsif val == :APPEND
9375
- 3
9376
- elsif val == :SET_AND_STEAL
9377
- 4
9378
- elsif val == :APPEND_AND_STEAL
9379
- 5
9380
- end
9925
+ return 0 if val == :ENUM_CONTROL_GROUP_ACTION_UNSET
9926
+ return 1 if val == :RECALL
9927
+ return 2 if val == :SET
9928
+ return 3 if val == :APPEND
9929
+ return 4 if val == :SET_AND_STEAL
9930
+ return 5 if val == :APPEND_AND_STEAL
9381
9931
  end
9382
9932
  end
9383
9933
  # required field readers
@@ -9393,6 +9943,7 @@ module Api
9393
9943
  # enum writers
9394
9944
  def action=(v)
9395
9945
  @action = Api::ActionControlGroup::ControlGroupAction.resolve(v) || v
9946
+ @_bitmask |= 0x0000000000000001
9396
9947
  end
9397
9948
 
9398
9949
  # BEGIN writers for optional fields
@@ -9435,6 +9986,10 @@ module Api
9435
9986
  self.class.encode(self)
9436
9987
  end
9437
9988
 
9989
+ def has_action?
9990
+ (@_bitmask & 0x0000000000000001) == 0x0000000000000001
9991
+ end
9992
+
9438
9993
  def has_control_group_index?
9439
9994
  (@_bitmask & 0x0000000000000002) == 0x0000000000000002
9440
9995
  end
@@ -9504,20 +10059,39 @@ module Api
9504
10059
  # unexpected, so discard it and continue.
9505
10060
  if !found
9506
10061
  wire_type = tag & 0x7
10062
+
10063
+ unknown_bytes = +"".b
10064
+ val = tag
10065
+ loop do
10066
+ byte = val & 0x7F
10067
+
10068
+ val >>= 7
10069
+ # This drops the top bits,
10070
+ # Otherwise, with a signed right shift,
10071
+ # we get infinity one bits at the top
10072
+ val &= (1 << 57) - 1
10073
+
10074
+ byte |= 0x80 if val != 0
10075
+ unknown_bytes << byte
10076
+ break if val == 0
10077
+ end
10078
+
9507
10079
  case wire_type
9508
10080
  when 0
9509
10081
  i = 0
9510
10082
  while true
9511
10083
  newbyte = buff.getbyte(index)
9512
10084
  index += 1
9513
- break if newbyte.nil? || newbyte < 0x80
10085
+ break if newbyte.nil?
10086
+ unknown_bytes << newbyte
10087
+ break if newbyte < 0x80
9514
10088
  i += 1
9515
10089
  break if i > 9
9516
10090
  end
9517
10091
  when 1
10092
+ unknown_bytes << buff.byteslice(index, 8)
9518
10093
  index += 8
9519
10094
  when 2
9520
- ## PULL_BYTES
9521
10095
  value =
9522
10096
  if (byte0 = buff.getbyte(index)) < 0x80
9523
10097
  index += 1
@@ -9573,15 +10147,30 @@ module Api
9573
10147
  raise "integer decoding error"
9574
10148
  end
9575
10149
 
9576
- buff.byteslice(index, value)
9577
- index += value
10150
+ val = value
10151
+ loop do
10152
+ byte = val & 0x7F
9578
10153
 
9579
- ## END PULL_BYTES
9580
- when 5
9581
- index += 4
10154
+ val >>= 7
10155
+ # This drops the top bits,
10156
+ # Otherwise, with a signed right shift,
10157
+ # we get infinity one bits at the top
10158
+ val &= (1 << 57) - 1
10159
+
10160
+ byte |= 0x80 if val != 0
10161
+ unknown_bytes << byte
10162
+ break if val == 0
10163
+ end
10164
+
10165
+ unknown_bytes << buff.byteslice(index, value)
10166
+ index += value
10167
+ when 5
10168
+ unknown_bytes << buff.byteslice(index, 4)
10169
+ index += 4
9582
10170
  else
9583
10171
  raise "unknown wire type #{wire_type}"
9584
10172
  end
10173
+ (@_unknown_fields ||= +"".b) << unknown_bytes
9585
10174
  return self if index >= len
9586
10175
  ## PULL_UINT64
9587
10176
  tag =
@@ -9871,10 +10460,10 @@ module Api
9871
10460
  end
9872
10461
  def _encode(buff)
9873
10462
  val = @action
9874
- if val != 0
10463
+ if has_action?
9875
10464
  buff << 0x08
9876
10465
 
9877
- while val != 0
10466
+ loop do
9878
10467
  byte = val & 0x7F
9879
10468
 
9880
10469
  val >>= 7
@@ -9885,30 +10474,50 @@ module Api
9885
10474
 
9886
10475
  byte |= 0x80 if val != 0
9887
10476
  buff << byte
10477
+ break if val == 0
9888
10478
  end
9889
10479
  end
9890
10480
 
9891
10481
  val = @control_group_index
9892
- if val != 0
10482
+ if has_control_group_index?
9893
10483
  buff << 0x10
9894
10484
 
9895
- while val != 0
10485
+ loop do
9896
10486
  byte = val & 0x7F
9897
10487
  val >>= 7
9898
10488
  byte |= 0x80 if val > 0
9899
10489
  buff << byte
10490
+ break if val == 0
9900
10491
  end
9901
10492
  end
9902
-
10493
+ buff << @_unknown_fields if @_unknown_fields
9903
10494
  buff
9904
10495
  end
9905
10496
 
9906
10497
  def to_h
9907
10498
  result = {}
9908
- result["action".to_sym] = @action
9909
- result["control_group_index".to_sym] = @control_group_index
10499
+
10500
+ result[:"action"] = @action
10501
+ result[:"control_group_index"] = @control_group_index
10502
+
9910
10503
  result
9911
10504
  end
10505
+
10506
+ def as_json(options = {})
10507
+ result = {}
10508
+
10509
+ result["action"] = @action if !options[:compact] || has_action?
10510
+ result["controlGroupIndex"] = @control_group_index if !options[
10511
+ :compact
10512
+ ] || has_control_group_index?
10513
+
10514
+ result
10515
+ end
10516
+
10517
+ def to_json(as_json_options = {})
10518
+ require "json"
10519
+ JSON.dump(as_json(as_json_options))
10520
+ end
9912
10521
  end
9913
10522
  class ActionSelectArmy
9914
10523
  def self.decode(buff)
@@ -10015,20 +10624,39 @@ module Api
10015
10624
  # unexpected, so discard it and continue.
10016
10625
  if !found
10017
10626
  wire_type = tag & 0x7
10627
+
10628
+ unknown_bytes = +"".b
10629
+ val = tag
10630
+ loop do
10631
+ byte = val & 0x7F
10632
+
10633
+ val >>= 7
10634
+ # This drops the top bits,
10635
+ # Otherwise, with a signed right shift,
10636
+ # we get infinity one bits at the top
10637
+ val &= (1 << 57) - 1
10638
+
10639
+ byte |= 0x80 if val != 0
10640
+ unknown_bytes << byte
10641
+ break if val == 0
10642
+ end
10643
+
10018
10644
  case wire_type
10019
10645
  when 0
10020
10646
  i = 0
10021
10647
  while true
10022
10648
  newbyte = buff.getbyte(index)
10023
10649
  index += 1
10024
- break if newbyte.nil? || newbyte < 0x80
10650
+ break if newbyte.nil?
10651
+ unknown_bytes << newbyte
10652
+ break if newbyte < 0x80
10025
10653
  i += 1
10026
10654
  break if i > 9
10027
10655
  end
10028
10656
  when 1
10657
+ unknown_bytes << buff.byteslice(index, 8)
10029
10658
  index += 8
10030
10659
  when 2
10031
- ## PULL_BYTES
10032
10660
  value =
10033
10661
  if (byte0 = buff.getbyte(index)) < 0x80
10034
10662
  index += 1
@@ -10084,15 +10712,30 @@ module Api
10084
10712
  raise "integer decoding error"
10085
10713
  end
10086
10714
 
10087
- buff.byteslice(index, value)
10088
- index += value
10715
+ val = value
10716
+ loop do
10717
+ byte = val & 0x7F
10718
+
10719
+ val >>= 7
10720
+ # This drops the top bits,
10721
+ # Otherwise, with a signed right shift,
10722
+ # we get infinity one bits at the top
10723
+ val &= (1 << 57) - 1
10089
10724
 
10090
- ## END PULL_BYTES
10725
+ byte |= 0x80 if val != 0
10726
+ unknown_bytes << byte
10727
+ break if val == 0
10728
+ end
10729
+
10730
+ unknown_bytes << buff.byteslice(index, value)
10731
+ index += value
10091
10732
  when 5
10733
+ unknown_bytes << buff.byteslice(index, 4)
10092
10734
  index += 4
10093
10735
  else
10094
10736
  raise "unknown wire type #{wire_type}"
10095
10737
  end
10738
+ (@_unknown_fields ||= +"".b) << unknown_bytes
10096
10739
  return self if index >= len
10097
10740
  ## PULL_UINT64
10098
10741
  tag =
@@ -10214,25 +10857,41 @@ module Api
10214
10857
  end
10215
10858
  end
10216
10859
  def _encode(buff)
10217
- val = @selection_add
10218
- if val == true
10860
+ if has_selection_add?
10861
+ val = @selection_add
10219
10862
  buff << 0x08
10220
10863
 
10221
- buff << 1
10222
- elsif val == false
10223
- # Default value, encode nothing
10224
- else
10225
- raise "bool values should be true or false"
10864
+ if val == true
10865
+ buff << 1
10866
+ elsif val == false
10867
+ buff << 0
10868
+ end
10226
10869
  end
10227
-
10870
+ buff << @_unknown_fields if @_unknown_fields
10228
10871
  buff
10229
10872
  end
10230
10873
 
10231
10874
  def to_h
10232
10875
  result = {}
10233
- result["selection_add".to_sym] = @selection_add
10876
+
10877
+ result[:"selection_add"] = @selection_add
10878
+
10234
10879
  result
10235
10880
  end
10881
+
10882
+ def as_json(options = {})
10883
+ result = {}
10884
+
10885
+ result["selectionAdd"] = @selection_add if !options[:compact] ||
10886
+ has_selection_add?
10887
+
10888
+ result
10889
+ end
10890
+
10891
+ def to_json(as_json_options = {})
10892
+ require "json"
10893
+ JSON.dump(as_json(as_json_options))
10894
+ end
10236
10895
  end
10237
10896
  class ActionSelectWarpGates
10238
10897
  def self.decode(buff)
@@ -10339,20 +10998,39 @@ module Api
10339
10998
  # unexpected, so discard it and continue.
10340
10999
  if !found
10341
11000
  wire_type = tag & 0x7
11001
+
11002
+ unknown_bytes = +"".b
11003
+ val = tag
11004
+ loop do
11005
+ byte = val & 0x7F
11006
+
11007
+ val >>= 7
11008
+ # This drops the top bits,
11009
+ # Otherwise, with a signed right shift,
11010
+ # we get infinity one bits at the top
11011
+ val &= (1 << 57) - 1
11012
+
11013
+ byte |= 0x80 if val != 0
11014
+ unknown_bytes << byte
11015
+ break if val == 0
11016
+ end
11017
+
10342
11018
  case wire_type
10343
11019
  when 0
10344
11020
  i = 0
10345
11021
  while true
10346
11022
  newbyte = buff.getbyte(index)
10347
11023
  index += 1
10348
- break if newbyte.nil? || newbyte < 0x80
11024
+ break if newbyte.nil?
11025
+ unknown_bytes << newbyte
11026
+ break if newbyte < 0x80
10349
11027
  i += 1
10350
11028
  break if i > 9
10351
11029
  end
10352
11030
  when 1
11031
+ unknown_bytes << buff.byteslice(index, 8)
10353
11032
  index += 8
10354
11033
  when 2
10355
- ## PULL_BYTES
10356
11034
  value =
10357
11035
  if (byte0 = buff.getbyte(index)) < 0x80
10358
11036
  index += 1
@@ -10408,15 +11086,30 @@ module Api
10408
11086
  raise "integer decoding error"
10409
11087
  end
10410
11088
 
10411
- buff.byteslice(index, value)
10412
- index += value
11089
+ val = value
11090
+ loop do
11091
+ byte = val & 0x7F
11092
+
11093
+ val >>= 7
11094
+ # This drops the top bits,
11095
+ # Otherwise, with a signed right shift,
11096
+ # we get infinity one bits at the top
11097
+ val &= (1 << 57) - 1
10413
11098
 
10414
- ## END PULL_BYTES
11099
+ byte |= 0x80 if val != 0
11100
+ unknown_bytes << byte
11101
+ break if val == 0
11102
+ end
11103
+
11104
+ unknown_bytes << buff.byteslice(index, value)
11105
+ index += value
10415
11106
  when 5
11107
+ unknown_bytes << buff.byteslice(index, 4)
10416
11108
  index += 4
10417
11109
  else
10418
11110
  raise "unknown wire type #{wire_type}"
10419
11111
  end
11112
+ (@_unknown_fields ||= +"".b) << unknown_bytes
10420
11113
  return self if index >= len
10421
11114
  ## PULL_UINT64
10422
11115
  tag =
@@ -10538,25 +11231,41 @@ module Api
10538
11231
  end
10539
11232
  end
10540
11233
  def _encode(buff)
10541
- val = @selection_add
10542
- if val == true
11234
+ if has_selection_add?
11235
+ val = @selection_add
10543
11236
  buff << 0x08
10544
11237
 
10545
- buff << 1
10546
- elsif val == false
10547
- # Default value, encode nothing
10548
- else
10549
- raise "bool values should be true or false"
11238
+ if val == true
11239
+ buff << 1
11240
+ elsif val == false
11241
+ buff << 0
11242
+ end
10550
11243
  end
10551
-
11244
+ buff << @_unknown_fields if @_unknown_fields
10552
11245
  buff
10553
11246
  end
10554
11247
 
10555
11248
  def to_h
10556
11249
  result = {}
10557
- result["selection_add".to_sym] = @selection_add
11250
+
11251
+ result[:"selection_add"] = @selection_add
11252
+
10558
11253
  result
10559
11254
  end
11255
+
11256
+ def as_json(options = {})
11257
+ result = {}
11258
+
11259
+ result["selectionAdd"] = @selection_add if !options[:compact] ||
11260
+ has_selection_add?
11261
+
11262
+ result
11263
+ end
11264
+
11265
+ def to_json(as_json_options = {})
11266
+ require "json"
11267
+ JSON.dump(as_json(as_json_options))
11268
+ end
10560
11269
  end
10561
11270
  class ActionSelectLarva
10562
11271
  def self.decode(buff)
@@ -10584,20 +11293,39 @@ module Api
10584
11293
  # unexpected, so discard it and continue.
10585
11294
  if !found
10586
11295
  wire_type = tag & 0x7
11296
+
11297
+ unknown_bytes = +"".b
11298
+ val = tag
11299
+ loop do
11300
+ byte = val & 0x7F
11301
+
11302
+ val >>= 7
11303
+ # This drops the top bits,
11304
+ # Otherwise, with a signed right shift,
11305
+ # we get infinity one bits at the top
11306
+ val &= (1 << 57) - 1
11307
+
11308
+ byte |= 0x80 if val != 0
11309
+ unknown_bytes << byte
11310
+ break if val == 0
11311
+ end
11312
+
10587
11313
  case wire_type
10588
11314
  when 0
10589
11315
  i = 0
10590
11316
  while true
10591
11317
  newbyte = buff.getbyte(index)
10592
11318
  index += 1
10593
- break if newbyte.nil? || newbyte < 0x80
11319
+ break if newbyte.nil?
11320
+ unknown_bytes << newbyte
11321
+ break if newbyte < 0x80
10594
11322
  i += 1
10595
11323
  break if i > 9
10596
11324
  end
10597
11325
  when 1
11326
+ unknown_bytes << buff.byteslice(index, 8)
10598
11327
  index += 8
10599
11328
  when 2
10600
- ## PULL_BYTES
10601
11329
  value =
10602
11330
  if (byte0 = buff.getbyte(index)) < 0x80
10603
11331
  index += 1
@@ -10653,15 +11381,30 @@ module Api
10653
11381
  raise "integer decoding error"
10654
11382
  end
10655
11383
 
10656
- buff.byteslice(index, value)
10657
- index += value
11384
+ val = value
11385
+ loop do
11386
+ byte = val & 0x7F
11387
+
11388
+ val >>= 7
11389
+ # This drops the top bits,
11390
+ # Otherwise, with a signed right shift,
11391
+ # we get infinity one bits at the top
11392
+ val &= (1 << 57) - 1
11393
+
11394
+ byte |= 0x80 if val != 0
11395
+ unknown_bytes << byte
11396
+ break if val == 0
11397
+ end
10658
11398
 
10659
- ## END PULL_BYTES
11399
+ unknown_bytes << buff.byteslice(index, value)
11400
+ index += value
10660
11401
  when 5
11402
+ unknown_bytes << buff.byteslice(index, 4)
10661
11403
  index += 4
10662
11404
  else
10663
11405
  raise "unknown wire type #{wire_type}"
10664
11406
  end
11407
+ (@_unknown_fields ||= +"".b) << unknown_bytes
10665
11408
  return self if index >= len
10666
11409
  ## PULL_UINT64
10667
11410
  tag =
@@ -10721,6 +11464,7 @@ module Api
10721
11464
  end
10722
11465
  end
10723
11466
  def _encode(buff)
11467
+ buff << @_unknown_fields if @_unknown_fields
10724
11468
  buff
10725
11469
  end
10726
11470
 
@@ -10729,6 +11473,17 @@ module Api
10729
11473
 
10730
11474
  result
10731
11475
  end
11476
+
11477
+ def as_json(options = {})
11478
+ result = {}
11479
+
11480
+ result
11481
+ end
11482
+
11483
+ def to_json(as_json_options = {})
11484
+ require "json"
11485
+ JSON.dump(as_json(as_json_options))
11486
+ end
10732
11487
  end
10733
11488
  class ActionSelectIdleWorker
10734
11489
  def self.decode(buff)
@@ -10746,31 +11501,19 @@ module Api
10746
11501
  ADD_ALL = 4
10747
11502
 
10748
11503
  def self.lookup(val)
10749
- if val == 0
10750
- :ENUM_ACTION_SELECT_IDLE_WORKER_TYPE_UNSET
10751
- elsif val == 1
10752
- :SET
10753
- elsif val == 2
10754
- :ADD
10755
- elsif val == 3
10756
- :ALL
10757
- elsif val == 4
10758
- :ADD_ALL
10759
- end
11504
+ return :ENUM_ACTION_SELECT_IDLE_WORKER_TYPE_UNSET if val == 0
11505
+ return :SET if val == 1
11506
+ return :ADD if val == 2
11507
+ return :ALL if val == 3
11508
+ return :ADD_ALL if val == 4
10760
11509
  end
10761
11510
 
10762
11511
  def self.resolve(val)
10763
- if val == :ENUM_ACTION_SELECT_IDLE_WORKER_TYPE_UNSET
10764
- 0
10765
- elsif val == :SET
10766
- 1
10767
- elsif val == :ADD
10768
- 2
10769
- elsif val == :ALL
10770
- 3
10771
- elsif val == :ADD_ALL
10772
- 4
10773
- end
11512
+ return 0 if val == :ENUM_ACTION_SELECT_IDLE_WORKER_TYPE_UNSET
11513
+ return 1 if val == :SET
11514
+ return 2 if val == :ADD
11515
+ return 3 if val == :ALL
11516
+ return 4 if val == :ADD_ALL
10774
11517
  end
10775
11518
  end
10776
11519
  # required field readers
@@ -10782,9 +11525,12 @@ module Api
10782
11525
  # enum writers
10783
11526
  def type=(v)
10784
11527
  @type = Api::ActionSelectIdleWorker::Type.resolve(v) || v
11528
+ @_bitmask |= 0x0000000000000001
10785
11529
  end
10786
11530
 
10787
11531
  def initialize(type: nil)
11532
+ @_bitmask = 0
11533
+
10788
11534
  if type == nil
10789
11535
  @type = 0
10790
11536
  else
@@ -10797,7 +11543,13 @@ module Api
10797
11543
  self.class.encode(self)
10798
11544
  end
10799
11545
 
11546
+ def has_type?
11547
+ (@_bitmask & 0x0000000000000001) == 0x0000000000000001
11548
+ end
11549
+
10800
11550
  def decode_from(buff, index, len)
11551
+ @_bitmask = 0
11552
+
10801
11553
  @type = 0
10802
11554
 
10803
11555
  return self if index >= len
@@ -10859,20 +11611,39 @@ module Api
10859
11611
  # unexpected, so discard it and continue.
10860
11612
  if !found
10861
11613
  wire_type = tag & 0x7
11614
+
11615
+ unknown_bytes = +"".b
11616
+ val = tag
11617
+ loop do
11618
+ byte = val & 0x7F
11619
+
11620
+ val >>= 7
11621
+ # This drops the top bits,
11622
+ # Otherwise, with a signed right shift,
11623
+ # we get infinity one bits at the top
11624
+ val &= (1 << 57) - 1
11625
+
11626
+ byte |= 0x80 if val != 0
11627
+ unknown_bytes << byte
11628
+ break if val == 0
11629
+ end
11630
+
10862
11631
  case wire_type
10863
11632
  when 0
10864
11633
  i = 0
10865
11634
  while true
10866
11635
  newbyte = buff.getbyte(index)
10867
11636
  index += 1
10868
- break if newbyte.nil? || newbyte < 0x80
11637
+ break if newbyte.nil?
11638
+ unknown_bytes << newbyte
11639
+ break if newbyte < 0x80
10869
11640
  i += 1
10870
11641
  break if i > 9
10871
11642
  end
10872
11643
  when 1
11644
+ unknown_bytes << buff.byteslice(index, 8)
10873
11645
  index += 8
10874
11646
  when 2
10875
- ## PULL_BYTES
10876
11647
  value =
10877
11648
  if (byte0 = buff.getbyte(index)) < 0x80
10878
11649
  index += 1
@@ -10928,15 +11699,30 @@ module Api
10928
11699
  raise "integer decoding error"
10929
11700
  end
10930
11701
 
10931
- buff.byteslice(index, value)
10932
- index += value
11702
+ val = value
11703
+ loop do
11704
+ byte = val & 0x7F
10933
11705
 
10934
- ## END PULL_BYTES
11706
+ val >>= 7
11707
+ # This drops the top bits,
11708
+ # Otherwise, with a signed right shift,
11709
+ # we get infinity one bits at the top
11710
+ val &= (1 << 57) - 1
11711
+
11712
+ byte |= 0x80 if val != 0
11713
+ unknown_bytes << byte
11714
+ break if val == 0
11715
+ end
11716
+
11717
+ unknown_bytes << buff.byteslice(index, value)
11718
+ index += value
10935
11719
  when 5
11720
+ unknown_bytes << buff.byteslice(index, 4)
10936
11721
  index += 4
10937
11722
  else
10938
11723
  raise "unknown wire type #{wire_type}"
10939
11724
  end
11725
+ (@_unknown_fields ||= +"".b) << unknown_bytes
10940
11726
  return self if index >= len
10941
11727
  ## PULL_UINT64
10942
11728
  tag =
@@ -11118,10 +11904,10 @@ module Api
11118
11904
  end
11119
11905
  def _encode(buff)
11120
11906
  val = @type
11121
- if val != 0
11907
+ if has_type?
11122
11908
  buff << 0x08
11123
11909
 
11124
- while val != 0
11910
+ loop do
11125
11911
  byte = val & 0x7F
11126
11912
 
11127
11913
  val >>= 7
@@ -11132,17 +11918,33 @@ module Api
11132
11918
 
11133
11919
  byte |= 0x80 if val != 0
11134
11920
  buff << byte
11921
+ break if val == 0
11135
11922
  end
11136
11923
  end
11137
-
11924
+ buff << @_unknown_fields if @_unknown_fields
11138
11925
  buff
11139
11926
  end
11140
11927
 
11141
11928
  def to_h
11142
11929
  result = {}
11143
- result["type".to_sym] = @type
11930
+
11931
+ result[:"type"] = @type
11932
+
11144
11933
  result
11145
11934
  end
11935
+
11936
+ def as_json(options = {})
11937
+ result = {}
11938
+
11939
+ result["type"] = @type if !options[:compact] || has_type?
11940
+
11941
+ result
11942
+ end
11943
+
11944
+ def to_json(as_json_options = {})
11945
+ require "json"
11946
+ JSON.dump(as_json(as_json_options))
11947
+ end
11146
11948
  end
11147
11949
  class ActionMultiPanel
11148
11950
  def self.decode(buff)
@@ -11160,31 +11962,19 @@ module Api
11160
11962
  DESELECT_ALL_OF_TYPE = 4
11161
11963
 
11162
11964
  def self.lookup(val)
11163
- if val == 0
11164
- :ENUM_ACTION_MULTI_PANEL_TYPE_UNSET
11165
- elsif val == 1
11166
- :SINGLE_SELECT
11167
- elsif val == 2
11168
- :DESELECT_UNIT
11169
- elsif val == 3
11170
- :SELECT_ALL_OF_TYPE
11171
- elsif val == 4
11172
- :DESELECT_ALL_OF_TYPE
11173
- end
11965
+ return :ENUM_ACTION_MULTI_PANEL_TYPE_UNSET if val == 0
11966
+ return :SINGLE_SELECT if val == 1
11967
+ return :DESELECT_UNIT if val == 2
11968
+ return :SELECT_ALL_OF_TYPE if val == 3
11969
+ return :DESELECT_ALL_OF_TYPE if val == 4
11174
11970
  end
11175
11971
 
11176
11972
  def self.resolve(val)
11177
- if val == :ENUM_ACTION_MULTI_PANEL_TYPE_UNSET
11178
- 0
11179
- elsif val == :SINGLE_SELECT
11180
- 1
11181
- elsif val == :DESELECT_UNIT
11182
- 2
11183
- elsif val == :SELECT_ALL_OF_TYPE
11184
- 3
11185
- elsif val == :DESELECT_ALL_OF_TYPE
11186
- 4
11187
- end
11973
+ return 0 if val == :ENUM_ACTION_MULTI_PANEL_TYPE_UNSET
11974
+ return 1 if val == :SINGLE_SELECT
11975
+ return 2 if val == :DESELECT_UNIT
11976
+ return 3 if val == :SELECT_ALL_OF_TYPE
11977
+ return 4 if val == :DESELECT_ALL_OF_TYPE
11188
11978
  end
11189
11979
  end
11190
11980
  # required field readers
@@ -11200,6 +11990,7 @@ module Api
11200
11990
  # enum writers
11201
11991
  def type=(v)
11202
11992
  @type = Api::ActionMultiPanel::Type.resolve(v) || v
11993
+ @_bitmask |= 0x0000000000000001
11203
11994
  end
11204
11995
 
11205
11996
  # BEGIN writers for optional fields
@@ -11241,6 +12032,10 @@ module Api
11241
12032
  self.class.encode(self)
11242
12033
  end
11243
12034
 
12035
+ def has_type?
12036
+ (@_bitmask & 0x0000000000000001) == 0x0000000000000001
12037
+ end
12038
+
11244
12039
  def has_unit_index?
11245
12040
  (@_bitmask & 0x0000000000000002) == 0x0000000000000002
11246
12041
  end
@@ -11310,20 +12105,39 @@ module Api
11310
12105
  # unexpected, so discard it and continue.
11311
12106
  if !found
11312
12107
  wire_type = tag & 0x7
12108
+
12109
+ unknown_bytes = +"".b
12110
+ val = tag
12111
+ loop do
12112
+ byte = val & 0x7F
12113
+
12114
+ val >>= 7
12115
+ # This drops the top bits,
12116
+ # Otherwise, with a signed right shift,
12117
+ # we get infinity one bits at the top
12118
+ val &= (1 << 57) - 1
12119
+
12120
+ byte |= 0x80 if val != 0
12121
+ unknown_bytes << byte
12122
+ break if val == 0
12123
+ end
12124
+
11313
12125
  case wire_type
11314
12126
  when 0
11315
12127
  i = 0
11316
12128
  while true
11317
12129
  newbyte = buff.getbyte(index)
11318
12130
  index += 1
11319
- break if newbyte.nil? || newbyte < 0x80
12131
+ break if newbyte.nil?
12132
+ unknown_bytes << newbyte
12133
+ break if newbyte < 0x80
11320
12134
  i += 1
11321
12135
  break if i > 9
11322
12136
  end
11323
12137
  when 1
12138
+ unknown_bytes << buff.byteslice(index, 8)
11324
12139
  index += 8
11325
12140
  when 2
11326
- ## PULL_BYTES
11327
12141
  value =
11328
12142
  if (byte0 = buff.getbyte(index)) < 0x80
11329
12143
  index += 1
@@ -11379,15 +12193,30 @@ module Api
11379
12193
  raise "integer decoding error"
11380
12194
  end
11381
12195
 
11382
- buff.byteslice(index, value)
11383
- index += value
12196
+ val = value
12197
+ loop do
12198
+ byte = val & 0x7F
12199
+
12200
+ val >>= 7
12201
+ # This drops the top bits,
12202
+ # Otherwise, with a signed right shift,
12203
+ # we get infinity one bits at the top
12204
+ val &= (1 << 57) - 1
12205
+
12206
+ byte |= 0x80 if val != 0
12207
+ unknown_bytes << byte
12208
+ break if val == 0
12209
+ end
11384
12210
 
11385
- ## END PULL_BYTES
12211
+ unknown_bytes << buff.byteslice(index, value)
12212
+ index += value
11386
12213
  when 5
12214
+ unknown_bytes << buff.byteslice(index, 4)
11387
12215
  index += 4
11388
12216
  else
11389
12217
  raise "unknown wire type #{wire_type}"
11390
12218
  end
12219
+ (@_unknown_fields ||= +"".b) << unknown_bytes
11391
12220
  return self if index >= len
11392
12221
  ## PULL_UINT64
11393
12222
  tag =
@@ -11689,10 +12518,10 @@ module Api
11689
12518
  end
11690
12519
  def _encode(buff)
11691
12520
  val = @type
11692
- if val != 0
12521
+ if has_type?
11693
12522
  buff << 0x08
11694
12523
 
11695
- while val != 0
12524
+ loop do
11696
12525
  byte = val & 0x7F
11697
12526
 
11698
12527
  val >>= 7
@@ -11703,14 +12532,15 @@ module Api
11703
12532
 
11704
12533
  byte |= 0x80 if val != 0
11705
12534
  buff << byte
12535
+ break if val == 0
11706
12536
  end
11707
12537
  end
11708
12538
 
11709
12539
  val = @unit_index
11710
- if val != 0
12540
+ if has_unit_index?
11711
12541
  buff << 0x10
11712
12542
 
11713
- while val != 0
12543
+ loop do
11714
12544
  byte = val & 0x7F
11715
12545
 
11716
12546
  val >>= 7
@@ -11721,18 +12551,35 @@ module Api
11721
12551
 
11722
12552
  byte |= 0x80 if val != 0
11723
12553
  buff << byte
12554
+ break if val == 0
11724
12555
  end
11725
12556
  end
11726
-
12557
+ buff << @_unknown_fields if @_unknown_fields
11727
12558
  buff
11728
12559
  end
11729
12560
 
11730
12561
  def to_h
11731
12562
  result = {}
11732
- result["type".to_sym] = @type
11733
- result["unit_index".to_sym] = @unit_index
12563
+
12564
+ result[:"type"] = @type
12565
+ result[:"unit_index"] = @unit_index
12566
+
11734
12567
  result
11735
12568
  end
12569
+
12570
+ def as_json(options = {})
12571
+ result = {}
12572
+
12573
+ result["type"] = @type if !options[:compact] || has_type?
12574
+ result["unitIndex"] = @unit_index if !options[:compact] || has_unit_index?
12575
+
12576
+ result
12577
+ end
12578
+
12579
+ def to_json(as_json_options = {})
12580
+ require "json"
12581
+ JSON.dump(as_json(as_json_options))
12582
+ end
11736
12583
  end
11737
12584
  class ActionCargoPanelUnload
11738
12585
  def self.decode(buff)
@@ -11848,20 +12695,39 @@ module Api
11848
12695
  # unexpected, so discard it and continue.
11849
12696
  if !found
11850
12697
  wire_type = tag & 0x7
12698
+
12699
+ unknown_bytes = +"".b
12700
+ val = tag
12701
+ loop do
12702
+ byte = val & 0x7F
12703
+
12704
+ val >>= 7
12705
+ # This drops the top bits,
12706
+ # Otherwise, with a signed right shift,
12707
+ # we get infinity one bits at the top
12708
+ val &= (1 << 57) - 1
12709
+
12710
+ byte |= 0x80 if val != 0
12711
+ unknown_bytes << byte
12712
+ break if val == 0
12713
+ end
12714
+
11851
12715
  case wire_type
11852
12716
  when 0
11853
12717
  i = 0
11854
12718
  while true
11855
12719
  newbyte = buff.getbyte(index)
11856
12720
  index += 1
11857
- break if newbyte.nil? || newbyte < 0x80
12721
+ break if newbyte.nil?
12722
+ unknown_bytes << newbyte
12723
+ break if newbyte < 0x80
11858
12724
  i += 1
11859
12725
  break if i > 9
11860
12726
  end
11861
12727
  when 1
12728
+ unknown_bytes << buff.byteslice(index, 8)
11862
12729
  index += 8
11863
12730
  when 2
11864
- ## PULL_BYTES
11865
12731
  value =
11866
12732
  if (byte0 = buff.getbyte(index)) < 0x80
11867
12733
  index += 1
@@ -11917,15 +12783,30 @@ module Api
11917
12783
  raise "integer decoding error"
11918
12784
  end
11919
12785
 
11920
- buff.byteslice(index, value)
11921
- index += value
12786
+ val = value
12787
+ loop do
12788
+ byte = val & 0x7F
12789
+
12790
+ val >>= 7
12791
+ # This drops the top bits,
12792
+ # Otherwise, with a signed right shift,
12793
+ # we get infinity one bits at the top
12794
+ val &= (1 << 57) - 1
12795
+
12796
+ byte |= 0x80 if val != 0
12797
+ unknown_bytes << byte
12798
+ break if val == 0
12799
+ end
11922
12800
 
11923
- ## END PULL_BYTES
12801
+ unknown_bytes << buff.byteslice(index, value)
12802
+ index += value
11924
12803
  when 5
12804
+ unknown_bytes << buff.byteslice(index, 4)
11925
12805
  index += 4
11926
12806
  else
11927
12807
  raise "unknown wire type #{wire_type}"
11928
12808
  end
12809
+ (@_unknown_fields ||= +"".b) << unknown_bytes
11929
12810
  return self if index >= len
11930
12811
  ## PULL_UINT64
11931
12812
  tag =
@@ -12107,10 +12988,10 @@ module Api
12107
12988
  end
12108
12989
  def _encode(buff)
12109
12990
  val = @unit_index
12110
- if val != 0
12991
+ if has_unit_index?
12111
12992
  buff << 0x08
12112
12993
 
12113
- while val != 0
12994
+ loop do
12114
12995
  byte = val & 0x7F
12115
12996
 
12116
12997
  val >>= 7
@@ -12121,17 +13002,33 @@ module Api
12121
13002
 
12122
13003
  byte |= 0x80 if val != 0
12123
13004
  buff << byte
13005
+ break if val == 0
12124
13006
  end
12125
13007
  end
12126
-
13008
+ buff << @_unknown_fields if @_unknown_fields
12127
13009
  buff
12128
13010
  end
12129
13011
 
12130
13012
  def to_h
12131
13013
  result = {}
12132
- result["unit_index".to_sym] = @unit_index
13014
+
13015
+ result[:"unit_index"] = @unit_index
13016
+
12133
13017
  result
12134
13018
  end
13019
+
13020
+ def as_json(options = {})
13021
+ result = {}
13022
+
13023
+ result["unitIndex"] = @unit_index if !options[:compact] || has_unit_index?
13024
+
13025
+ result
13026
+ end
13027
+
13028
+ def to_json(as_json_options = {})
13029
+ require "json"
13030
+ JSON.dump(as_json(as_json_options))
13031
+ end
12135
13032
  end
12136
13033
  class ActionProductionPanelRemoveFromQueue
12137
13034
  def self.decode(buff)
@@ -12247,20 +13144,39 @@ module Api
12247
13144
  # unexpected, so discard it and continue.
12248
13145
  if !found
12249
13146
  wire_type = tag & 0x7
13147
+
13148
+ unknown_bytes = +"".b
13149
+ val = tag
13150
+ loop do
13151
+ byte = val & 0x7F
13152
+
13153
+ val >>= 7
13154
+ # This drops the top bits,
13155
+ # Otherwise, with a signed right shift,
13156
+ # we get infinity one bits at the top
13157
+ val &= (1 << 57) - 1
13158
+
13159
+ byte |= 0x80 if val != 0
13160
+ unknown_bytes << byte
13161
+ break if val == 0
13162
+ end
13163
+
12250
13164
  case wire_type
12251
13165
  when 0
12252
13166
  i = 0
12253
13167
  while true
12254
13168
  newbyte = buff.getbyte(index)
12255
13169
  index += 1
12256
- break if newbyte.nil? || newbyte < 0x80
13170
+ break if newbyte.nil?
13171
+ unknown_bytes << newbyte
13172
+ break if newbyte < 0x80
12257
13173
  i += 1
12258
13174
  break if i > 9
12259
13175
  end
12260
13176
  when 1
13177
+ unknown_bytes << buff.byteslice(index, 8)
12261
13178
  index += 8
12262
13179
  when 2
12263
- ## PULL_BYTES
12264
13180
  value =
12265
13181
  if (byte0 = buff.getbyte(index)) < 0x80
12266
13182
  index += 1
@@ -12316,15 +13232,30 @@ module Api
12316
13232
  raise "integer decoding error"
12317
13233
  end
12318
13234
 
12319
- buff.byteslice(index, value)
12320
- index += value
13235
+ val = value
13236
+ loop do
13237
+ byte = val & 0x7F
12321
13238
 
12322
- ## END PULL_BYTES
13239
+ val >>= 7
13240
+ # This drops the top bits,
13241
+ # Otherwise, with a signed right shift,
13242
+ # we get infinity one bits at the top
13243
+ val &= (1 << 57) - 1
13244
+
13245
+ byte |= 0x80 if val != 0
13246
+ unknown_bytes << byte
13247
+ break if val == 0
13248
+ end
13249
+
13250
+ unknown_bytes << buff.byteslice(index, value)
13251
+ index += value
12323
13252
  when 5
13253
+ unknown_bytes << buff.byteslice(index, 4)
12324
13254
  index += 4
12325
13255
  else
12326
13256
  raise "unknown wire type #{wire_type}"
12327
13257
  end
13258
+ (@_unknown_fields ||= +"".b) << unknown_bytes
12328
13259
  return self if index >= len
12329
13260
  ## PULL_UINT64
12330
13261
  tag =
@@ -12506,10 +13437,10 @@ module Api
12506
13437
  end
12507
13438
  def _encode(buff)
12508
13439
  val = @unit_index
12509
- if val != 0
13440
+ if has_unit_index?
12510
13441
  buff << 0x08
12511
13442
 
12512
- while val != 0
13443
+ loop do
12513
13444
  byte = val & 0x7F
12514
13445
 
12515
13446
  val >>= 7
@@ -12520,17 +13451,33 @@ module Api
12520
13451
 
12521
13452
  byte |= 0x80 if val != 0
12522
13453
  buff << byte
13454
+ break if val == 0
12523
13455
  end
12524
13456
  end
12525
-
13457
+ buff << @_unknown_fields if @_unknown_fields
12526
13458
  buff
12527
13459
  end
12528
13460
 
12529
13461
  def to_h
12530
13462
  result = {}
12531
- result["unit_index".to_sym] = @unit_index
13463
+
13464
+ result[:"unit_index"] = @unit_index
13465
+
12532
13466
  result
12533
13467
  end
13468
+
13469
+ def as_json(options = {})
13470
+ result = {}
13471
+
13472
+ result["unitIndex"] = @unit_index if !options[:compact] || has_unit_index?
13473
+
13474
+ result
13475
+ end
13476
+
13477
+ def to_json(as_json_options = {})
13478
+ require "json"
13479
+ JSON.dump(as_json(as_json_options))
13480
+ end
12534
13481
  end
12535
13482
  class ActionToggleAutocast
12536
13483
  def self.decode(buff)
@@ -12646,20 +13593,39 @@ module Api
12646
13593
  # unexpected, so discard it and continue.
12647
13594
  if !found
12648
13595
  wire_type = tag & 0x7
13596
+
13597
+ unknown_bytes = +"".b
13598
+ val = tag
13599
+ loop do
13600
+ byte = val & 0x7F
13601
+
13602
+ val >>= 7
13603
+ # This drops the top bits,
13604
+ # Otherwise, with a signed right shift,
13605
+ # we get infinity one bits at the top
13606
+ val &= (1 << 57) - 1
13607
+
13608
+ byte |= 0x80 if val != 0
13609
+ unknown_bytes << byte
13610
+ break if val == 0
13611
+ end
13612
+
12649
13613
  case wire_type
12650
13614
  when 0
12651
13615
  i = 0
12652
13616
  while true
12653
13617
  newbyte = buff.getbyte(index)
12654
13618
  index += 1
12655
- break if newbyte.nil? || newbyte < 0x80
13619
+ break if newbyte.nil?
13620
+ unknown_bytes << newbyte
13621
+ break if newbyte < 0x80
12656
13622
  i += 1
12657
13623
  break if i > 9
12658
13624
  end
12659
13625
  when 1
13626
+ unknown_bytes << buff.byteslice(index, 8)
12660
13627
  index += 8
12661
13628
  when 2
12662
- ## PULL_BYTES
12663
13629
  value =
12664
13630
  if (byte0 = buff.getbyte(index)) < 0x80
12665
13631
  index += 1
@@ -12715,15 +13681,30 @@ module Api
12715
13681
  raise "integer decoding error"
12716
13682
  end
12717
13683
 
12718
- buff.byteslice(index, value)
12719
- index += value
13684
+ val = value
13685
+ loop do
13686
+ byte = val & 0x7F
13687
+
13688
+ val >>= 7
13689
+ # This drops the top bits,
13690
+ # Otherwise, with a signed right shift,
13691
+ # we get infinity one bits at the top
13692
+ val &= (1 << 57) - 1
13693
+
13694
+ byte |= 0x80 if val != 0
13695
+ unknown_bytes << byte
13696
+ break if val == 0
13697
+ end
12720
13698
 
12721
- ## END PULL_BYTES
13699
+ unknown_bytes << buff.byteslice(index, value)
13700
+ index += value
12722
13701
  when 5
13702
+ unknown_bytes << buff.byteslice(index, 4)
12723
13703
  index += 4
12724
13704
  else
12725
13705
  raise "unknown wire type #{wire_type}"
12726
13706
  end
13707
+ (@_unknown_fields ||= +"".b) << unknown_bytes
12727
13708
  return self if index >= len
12728
13709
  ## PULL_UINT64
12729
13710
  tag =
@@ -12905,10 +13886,10 @@ module Api
12905
13886
  end
12906
13887
  def _encode(buff)
12907
13888
  val = @ability_id
12908
- if val != 0
13889
+ if has_ability_id?
12909
13890
  buff << 0x08
12910
13891
 
12911
- while val != 0
13892
+ loop do
12912
13893
  byte = val & 0x7F
12913
13894
 
12914
13895
  val >>= 7
@@ -12919,16 +13900,32 @@ module Api
12919
13900
 
12920
13901
  byte |= 0x80 if val != 0
12921
13902
  buff << byte
13903
+ break if val == 0
12922
13904
  end
12923
13905
  end
12924
-
13906
+ buff << @_unknown_fields if @_unknown_fields
12925
13907
  buff
12926
13908
  end
12927
13909
 
12928
13910
  def to_h
12929
13911
  result = {}
12930
- result["ability_id".to_sym] = @ability_id
13912
+
13913
+ result[:"ability_id"] = @ability_id
13914
+
13915
+ result
13916
+ end
13917
+
13918
+ def as_json(options = {})
13919
+ result = {}
13920
+
13921
+ result["abilityId"] = @ability_id if !options[:compact] || has_ability_id?
13922
+
12931
13923
  result
12932
13924
  end
13925
+
13926
+ def to_json(as_json_options = {})
13927
+ require "json"
13928
+ JSON.dump(as_json(as_json_options))
13929
+ end
12933
13930
  end
12934
13931
  end