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
@@ -19,63 +19,35 @@ module Api
19
19
  FAST_BUILD = 12
20
20
 
21
21
  def self.lookup(val)
22
- if val == 0
23
- :ENUM_DEBUG_GAME_STATE_UNSET
24
- elsif val == 1
25
- :SHOW_MAP
26
- elsif val == 2
27
- :CONTROL_ENEMY
28
- elsif val == 3
29
- :FOOD
30
- elsif val == 4
31
- :FREE
32
- elsif val == 5
33
- :ALL_RESOURCES
34
- elsif val == 6
35
- :GOD
36
- elsif val == 7
37
- :MINERALS
38
- elsif val == 8
39
- :GAS
40
- elsif val == 9
41
- :COOLDOWNS
42
- elsif val == 10
43
- :TECH_TREE
44
- elsif val == 11
45
- :UPGRADE
46
- elsif val == 12
47
- :FAST_BUILD
48
- end
22
+ return :ENUM_DEBUG_GAME_STATE_UNSET if val == 0
23
+ return :SHOW_MAP if val == 1
24
+ return :CONTROL_ENEMY if val == 2
25
+ return :FOOD if val == 3
26
+ return :FREE if val == 4
27
+ return :ALL_RESOURCES if val == 5
28
+ return :GOD if val == 6
29
+ return :MINERALS if val == 7
30
+ return :GAS if val == 8
31
+ return :COOLDOWNS if val == 9
32
+ return :TECH_TREE if val == 10
33
+ return :UPGRADE if val == 11
34
+ return :FAST_BUILD if val == 12
49
35
  end
50
36
 
51
37
  def self.resolve(val)
52
- if val == :ENUM_DEBUG_GAME_STATE_UNSET
53
- 0
54
- elsif val == :SHOW_MAP
55
- 1
56
- elsif val == :CONTROL_ENEMY
57
- 2
58
- elsif val == :FOOD
59
- 3
60
- elsif val == :FREE
61
- 4
62
- elsif val == :ALL_RESOURCES
63
- 5
64
- elsif val == :GOD
65
- 6
66
- elsif val == :MINERALS
67
- 7
68
- elsif val == :GAS
69
- 8
70
- elsif val == :COOLDOWNS
71
- 9
72
- elsif val == :TECH_TREE
73
- 10
74
- elsif val == :UPGRADE
75
- 11
76
- elsif val == :FAST_BUILD
77
- 12
78
- end
38
+ return 0 if val == :ENUM_DEBUG_GAME_STATE_UNSET
39
+ return 1 if val == :SHOW_MAP
40
+ return 2 if val == :CONTROL_ENEMY
41
+ return 3 if val == :FOOD
42
+ return 4 if val == :FREE
43
+ return 5 if val == :ALL_RESOURCES
44
+ return 6 if val == :GOD
45
+ return 7 if val == :MINERALS
46
+ return 8 if val == :GAS
47
+ return 9 if val == :COOLDOWNS
48
+ return 10 if val == :TECH_TREE
49
+ return 11 if val == :UPGRADE
50
+ return 12 if val == :FAST_BUILD
79
51
  end
80
52
  end
81
53
 
@@ -293,20 +265,39 @@ module Api
293
265
  # unexpected, so discard it and continue.
294
266
  if !found
295
267
  wire_type = tag & 0x7
268
+
269
+ unknown_bytes = +"".b
270
+ val = tag
271
+ loop do
272
+ byte = val & 0x7F
273
+
274
+ val >>= 7
275
+ # This drops the top bits,
276
+ # Otherwise, with a signed right shift,
277
+ # we get infinity one bits at the top
278
+ val &= (1 << 57) - 1
279
+
280
+ byte |= 0x80 if val != 0
281
+ unknown_bytes << byte
282
+ break if val == 0
283
+ end
284
+
296
285
  case wire_type
297
286
  when 0
298
287
  i = 0
299
288
  while true
300
289
  newbyte = buff.getbyte(index)
301
290
  index += 1
302
- break if newbyte.nil? || newbyte < 0x80
291
+ break if newbyte.nil?
292
+ unknown_bytes << newbyte
293
+ break if newbyte < 0x80
303
294
  i += 1
304
295
  break if i > 9
305
296
  end
306
297
  when 1
298
+ unknown_bytes << buff.byteslice(index, 8)
307
299
  index += 8
308
300
  when 2
309
- ## PULL_BYTES
310
301
  value =
311
302
  if (byte0 = buff.getbyte(index)) < 0x80
312
303
  index += 1
@@ -362,15 +353,30 @@ module Api
362
353
  raise "integer decoding error"
363
354
  end
364
355
 
365
- buff.byteslice(index, value)
366
- index += value
356
+ val = value
357
+ loop do
358
+ byte = val & 0x7F
359
+
360
+ val >>= 7
361
+ # This drops the top bits,
362
+ # Otherwise, with a signed right shift,
363
+ # we get infinity one bits at the top
364
+ val &= (1 << 57) - 1
365
+
366
+ byte |= 0x80 if val != 0
367
+ unknown_bytes << byte
368
+ break if val == 0
369
+ end
367
370
 
368
- ## END PULL_BYTES
371
+ unknown_bytes << buff.byteslice(index, value)
372
+ index += value
369
373
  when 5
374
+ unknown_bytes << buff.byteslice(index, 4)
370
375
  index += 4
371
376
  else
372
377
  raise "unknown wire type #{wire_type}"
373
378
  end
379
+ (@_unknown_fields ||= +"".b) << unknown_bytes
374
380
  return self if index >= len
375
381
  ## PULL_UINT64
376
382
  tag =
@@ -1418,7 +1424,7 @@ module Api
1418
1424
  if val != 0
1419
1425
  buff << 0x10
1420
1426
 
1421
- while val != 0
1427
+ loop do
1422
1428
  byte = val & 0x7F
1423
1429
 
1424
1430
  val >>= 7
@@ -1429,6 +1435,7 @@ module Api
1429
1435
 
1430
1436
  byte |= 0x80 if val != 0
1431
1437
  buff << byte
1438
+ break if val == 0
1432
1439
  end
1433
1440
  end
1434
1441
 
@@ -1719,15 +1726,93 @@ module Api
1719
1726
 
1720
1727
  buff
1721
1728
  end
1722
-
1729
+ buff << @_unknown_fields if @_unknown_fields
1723
1730
  buff
1724
1731
  end
1725
1732
 
1726
1733
  def to_h
1727
1734
  result = {}
1728
- send("command").tap { |f| result[f.to_sym] = send(f) if f }
1735
+
1736
+ resolved_command = self.command
1737
+
1738
+ result[:"draw"] = @draw.to_h if resolved_command == :"draw"
1739
+ result[:"game_state"] = @game_state if resolved_command == :"game_state"
1740
+ result[:"create_unit"] = @create_unit.to_h if resolved_command ==
1741
+ :"create_unit"
1742
+ result[:"kill_unit"] = @kill_unit.to_h if resolved_command == :"kill_unit"
1743
+ result[:"test_process"] = @test_process.to_h if resolved_command ==
1744
+ :"test_process"
1745
+ result[:"score"] = @score.to_h if resolved_command == :"score"
1746
+ result[:"end_game"] = @end_game.to_h if resolved_command == :"end_game"
1747
+ result[:"unit_value"] = @unit_value.to_h if resolved_command ==
1748
+ :"unit_value"
1749
+
1750
+ result
1751
+ end
1752
+
1753
+ def as_json(options = {})
1754
+ result = {}
1755
+
1756
+ resolved_command = self.command
1757
+
1758
+ result["draw"] = (
1759
+ if @draw.nil?
1760
+ {}
1761
+ else
1762
+ @draw.as_json(options)
1763
+ end
1764
+ ) if resolved_command == :"draw"
1765
+ result["gameState"] = @game_state if resolved_command == :"game_state"
1766
+ result["createUnit"] = (
1767
+ if @create_unit.nil?
1768
+ {}
1769
+ else
1770
+ @create_unit.as_json(options)
1771
+ end
1772
+ ) if resolved_command == :"create_unit"
1773
+ result["killUnit"] = (
1774
+ if @kill_unit.nil?
1775
+ {}
1776
+ else
1777
+ @kill_unit.as_json(options)
1778
+ end
1779
+ ) if resolved_command == :"kill_unit"
1780
+ result["testProcess"] = (
1781
+ if @test_process.nil?
1782
+ {}
1783
+ else
1784
+ @test_process.as_json(options)
1785
+ end
1786
+ ) if resolved_command == :"test_process"
1787
+ result["score"] = (
1788
+ if @score.nil?
1789
+ {}
1790
+ else
1791
+ @score.as_json(options)
1792
+ end
1793
+ ) if resolved_command == :"score"
1794
+ result["endGame"] = (
1795
+ if @end_game.nil?
1796
+ {}
1797
+ else
1798
+ @end_game.as_json(options)
1799
+ end
1800
+ ) if resolved_command == :"end_game"
1801
+ result["unitValue"] = (
1802
+ if @unit_value.nil?
1803
+ {}
1804
+ else
1805
+ @unit_value.as_json(options)
1806
+ end
1807
+ ) if resolved_command == :"unit_value"
1808
+
1729
1809
  result
1730
1810
  end
1811
+
1812
+ def to_json(as_json_options = {})
1813
+ require "json"
1814
+ JSON.dump(as_json(as_json_options))
1815
+ end
1731
1816
  end
1732
1817
  class DebugDraw
1733
1818
  def self.decode(buff)
@@ -1842,20 +1927,39 @@ module Api
1842
1927
  # unexpected, so discard it and continue.
1843
1928
  if !found
1844
1929
  wire_type = tag & 0x7
1930
+
1931
+ unknown_bytes = +"".b
1932
+ val = tag
1933
+ loop do
1934
+ byte = val & 0x7F
1935
+
1936
+ val >>= 7
1937
+ # This drops the top bits,
1938
+ # Otherwise, with a signed right shift,
1939
+ # we get infinity one bits at the top
1940
+ val &= (1 << 57) - 1
1941
+
1942
+ byte |= 0x80 if val != 0
1943
+ unknown_bytes << byte
1944
+ break if val == 0
1945
+ end
1946
+
1845
1947
  case wire_type
1846
1948
  when 0
1847
1949
  i = 0
1848
1950
  while true
1849
1951
  newbyte = buff.getbyte(index)
1850
1952
  index += 1
1851
- break if newbyte.nil? || newbyte < 0x80
1953
+ break if newbyte.nil?
1954
+ unknown_bytes << newbyte
1955
+ break if newbyte < 0x80
1852
1956
  i += 1
1853
1957
  break if i > 9
1854
1958
  end
1855
1959
  when 1
1960
+ unknown_bytes << buff.byteslice(index, 8)
1856
1961
  index += 8
1857
1962
  when 2
1858
- ## PULL_BYTES
1859
1963
  value =
1860
1964
  if (byte0 = buff.getbyte(index)) < 0x80
1861
1965
  index += 1
@@ -1911,15 +2015,30 @@ module Api
1911
2015
  raise "integer decoding error"
1912
2016
  end
1913
2017
 
1914
- buff.byteslice(index, value)
1915
- index += value
2018
+ val = value
2019
+ loop do
2020
+ byte = val & 0x7F
2021
+
2022
+ val >>= 7
2023
+ # This drops the top bits,
2024
+ # Otherwise, with a signed right shift,
2025
+ # we get infinity one bits at the top
2026
+ val &= (1 << 57) - 1
2027
+
2028
+ byte |= 0x80 if val != 0
2029
+ unknown_bytes << byte
2030
+ break if val == 0
2031
+ end
1916
2032
 
1917
- ## END PULL_BYTES
2033
+ unknown_bytes << buff.byteslice(index, value)
2034
+ index += value
1918
2035
  when 5
2036
+ unknown_bytes << buff.byteslice(index, 4)
1919
2037
  index += 4
1920
2038
  else
1921
2039
  raise "unknown wire type #{wire_type}"
1922
2040
  end
2041
+ (@_unknown_fields ||= +"".b) << unknown_bytes
1923
2042
  return self if index >= len
1924
2043
  ## PULL_UINT64
1925
2044
  tag =
@@ -2735,18 +2854,47 @@ module Api
2735
2854
  end
2736
2855
  end
2737
2856
  end
2738
-
2857
+ buff << @_unknown_fields if @_unknown_fields
2739
2858
  buff
2740
2859
  end
2741
2860
 
2742
2861
  def to_h
2743
2862
  result = {}
2744
- result["text".to_sym] = @text
2745
- result["lines".to_sym] = @lines
2746
- result["boxes".to_sym] = @boxes
2747
- result["spheres".to_sym] = @spheres
2863
+
2864
+ result[:"text"] = @text.map(&:to_h)
2865
+ result[:"lines"] = @lines.map(&:to_h)
2866
+ result[:"boxes"] = @boxes.map(&:to_h)
2867
+ result[:"spheres"] = @spheres.map(&:to_h)
2868
+
2869
+ result
2870
+ end
2871
+
2872
+ def as_json(options = {})
2873
+ result = {}
2874
+
2875
+ tmp_text = @text.map { |v| v.as_json(options) }
2876
+
2877
+ result["text"] = tmp_text if !options[:compact] || tmp_text.any?
2878
+
2879
+ tmp_lines = @lines.map { |v| v.as_json(options) }
2880
+
2881
+ result["lines"] = tmp_lines if !options[:compact] || tmp_lines.any?
2882
+
2883
+ tmp_boxes = @boxes.map { |v| v.as_json(options) }
2884
+
2885
+ result["boxes"] = tmp_boxes if !options[:compact] || tmp_boxes.any?
2886
+
2887
+ tmp_spheres = @spheres.map { |v| v.as_json(options) }
2888
+
2889
+ result["spheres"] = tmp_spheres if !options[:compact] || tmp_spheres.any?
2890
+
2748
2891
  result
2749
2892
  end
2893
+
2894
+ def to_json(as_json_options = {})
2895
+ require "json"
2896
+ JSON.dump(as_json(as_json_options))
2897
+ end
2750
2898
  end
2751
2899
  class Line
2752
2900
  def self.decode(buff)
@@ -2872,20 +3020,39 @@ module Api
2872
3020
  # unexpected, so discard it and continue.
2873
3021
  if !found
2874
3022
  wire_type = tag & 0x7
3023
+
3024
+ unknown_bytes = +"".b
3025
+ val = tag
3026
+ loop do
3027
+ byte = val & 0x7F
3028
+
3029
+ val >>= 7
3030
+ # This drops the top bits,
3031
+ # Otherwise, with a signed right shift,
3032
+ # we get infinity one bits at the top
3033
+ val &= (1 << 57) - 1
3034
+
3035
+ byte |= 0x80 if val != 0
3036
+ unknown_bytes << byte
3037
+ break if val == 0
3038
+ end
3039
+
2875
3040
  case wire_type
2876
3041
  when 0
2877
3042
  i = 0
2878
3043
  while true
2879
3044
  newbyte = buff.getbyte(index)
2880
3045
  index += 1
2881
- break if newbyte.nil? || newbyte < 0x80
3046
+ break if newbyte.nil?
3047
+ unknown_bytes << newbyte
3048
+ break if newbyte < 0x80
2882
3049
  i += 1
2883
3050
  break if i > 9
2884
3051
  end
2885
3052
  when 1
3053
+ unknown_bytes << buff.byteslice(index, 8)
2886
3054
  index += 8
2887
3055
  when 2
2888
- ## PULL_BYTES
2889
3056
  value =
2890
3057
  if (byte0 = buff.getbyte(index)) < 0x80
2891
3058
  index += 1
@@ -2941,15 +3108,30 @@ module Api
2941
3108
  raise "integer decoding error"
2942
3109
  end
2943
3110
 
2944
- buff.byteslice(index, value)
2945
- index += value
3111
+ val = value
3112
+ loop do
3113
+ byte = val & 0x7F
2946
3114
 
2947
- ## END PULL_BYTES
3115
+ val >>= 7
3116
+ # This drops the top bits,
3117
+ # Otherwise, with a signed right shift,
3118
+ # we get infinity one bits at the top
3119
+ val &= (1 << 57) - 1
3120
+
3121
+ byte |= 0x80 if val != 0
3122
+ unknown_bytes << byte
3123
+ break if val == 0
3124
+ end
3125
+
3126
+ unknown_bytes << buff.byteslice(index, value)
3127
+ index += value
2948
3128
  when 5
3129
+ unknown_bytes << buff.byteslice(index, 4)
2949
3130
  index += 4
2950
3131
  else
2951
3132
  raise "unknown wire type #{wire_type}"
2952
3133
  end
3134
+ (@_unknown_fields ||= +"".b) << unknown_bytes
2953
3135
  return self if index >= len
2954
3136
  ## PULL_UINT64
2955
3137
  tag =
@@ -3329,16 +3511,36 @@ module Api
3329
3511
 
3330
3512
  buff
3331
3513
  end
3332
-
3514
+ buff << @_unknown_fields if @_unknown_fields
3333
3515
  buff
3334
3516
  end
3335
3517
 
3336
3518
  def to_h
3337
3519
  result = {}
3338
- result["p0".to_sym] = @p0.to_h
3339
- result["p1".to_sym] = @p1.to_h
3520
+
3521
+ result[:"p0"] = @p0.to_h
3522
+ result[:"p1"] = @p1.to_h
3523
+
3524
+ result
3525
+ end
3526
+
3527
+ def as_json(options = {})
3528
+ result = {}
3529
+
3530
+ result["p0"] = @p0.nil? ? {} : @p0.as_json(options) if !options[
3531
+ :compact
3532
+ ] || has_p0?
3533
+ result["p1"] = @p1.nil? ? {} : @p1.as_json(options) if !options[
3534
+ :compact
3535
+ ] || has_p1?
3536
+
3340
3537
  result
3341
3538
  end
3539
+
3540
+ def to_json(as_json_options = {})
3541
+ require "json"
3542
+ JSON.dump(as_json(as_json_options))
3543
+ end
3342
3544
  end
3343
3545
  class Color
3344
3546
  def self.decode(buff)
@@ -3510,20 +3712,39 @@ module Api
3510
3712
  # unexpected, so discard it and continue.
3511
3713
  if !found
3512
3714
  wire_type = tag & 0x7
3715
+
3716
+ unknown_bytes = +"".b
3717
+ val = tag
3718
+ loop do
3719
+ byte = val & 0x7F
3720
+
3721
+ val >>= 7
3722
+ # This drops the top bits,
3723
+ # Otherwise, with a signed right shift,
3724
+ # we get infinity one bits at the top
3725
+ val &= (1 << 57) - 1
3726
+
3727
+ byte |= 0x80 if val != 0
3728
+ unknown_bytes << byte
3729
+ break if val == 0
3730
+ end
3731
+
3513
3732
  case wire_type
3514
3733
  when 0
3515
3734
  i = 0
3516
3735
  while true
3517
3736
  newbyte = buff.getbyte(index)
3518
3737
  index += 1
3519
- break if newbyte.nil? || newbyte < 0x80
3738
+ break if newbyte.nil?
3739
+ unknown_bytes << newbyte
3740
+ break if newbyte < 0x80
3520
3741
  i += 1
3521
3742
  break if i > 9
3522
3743
  end
3523
3744
  when 1
3745
+ unknown_bytes << buff.byteslice(index, 8)
3524
3746
  index += 8
3525
3747
  when 2
3526
- ## PULL_BYTES
3527
3748
  value =
3528
3749
  if (byte0 = buff.getbyte(index)) < 0x80
3529
3750
  index += 1
@@ -3579,15 +3800,30 @@ module Api
3579
3800
  raise "integer decoding error"
3580
3801
  end
3581
3802
 
3582
- buff.byteslice(index, value)
3583
- index += value
3803
+ val = value
3804
+ loop do
3805
+ byte = val & 0x7F
3806
+
3807
+ val >>= 7
3808
+ # This drops the top bits,
3809
+ # Otherwise, with a signed right shift,
3810
+ # we get infinity one bits at the top
3811
+ val &= (1 << 57) - 1
3812
+
3813
+ byte |= 0x80 if val != 0
3814
+ unknown_bytes << byte
3815
+ break if val == 0
3816
+ end
3584
3817
 
3585
- ## END PULL_BYTES
3818
+ unknown_bytes << buff.byteslice(index, value)
3819
+ index += value
3586
3820
  when 5
3821
+ unknown_bytes << buff.byteslice(index, 4)
3587
3822
  index += 4
3588
3823
  else
3589
3824
  raise "unknown wire type #{wire_type}"
3590
3825
  end
3826
+ (@_unknown_fields ||= +"".b) << unknown_bytes
3591
3827
  return self if index >= len
3592
3828
  ## PULL_UINT64
3593
3829
  tag =
@@ -3973,51 +4209,71 @@ module Api
3973
4209
  end
3974
4210
  def _encode(buff)
3975
4211
  val = @r
3976
- if val != 0
4212
+ if has_r?
3977
4213
  buff << 0x08
3978
4214
 
3979
- while val != 0
4215
+ loop do
3980
4216
  byte = val & 0x7F
3981
4217
  val >>= 7
3982
4218
  byte |= 0x80 if val > 0
3983
4219
  buff << byte
4220
+ break if val == 0
3984
4221
  end
3985
4222
  end
3986
4223
 
3987
4224
  val = @g
3988
- if val != 0
4225
+ if has_g?
3989
4226
  buff << 0x10
3990
4227
 
3991
- while val != 0
4228
+ loop do
3992
4229
  byte = val & 0x7F
3993
4230
  val >>= 7
3994
4231
  byte |= 0x80 if val > 0
3995
4232
  buff << byte
4233
+ break if val == 0
3996
4234
  end
3997
4235
  end
3998
4236
 
3999
4237
  val = @b
4000
- if val != 0
4238
+ if has_b?
4001
4239
  buff << 0x18
4002
4240
 
4003
- while val != 0
4241
+ loop do
4004
4242
  byte = val & 0x7F
4005
4243
  val >>= 7
4006
4244
  byte |= 0x80 if val > 0
4007
4245
  buff << byte
4246
+ break if val == 0
4008
4247
  end
4009
4248
  end
4010
-
4249
+ buff << @_unknown_fields if @_unknown_fields
4011
4250
  buff
4012
4251
  end
4013
4252
 
4014
4253
  def to_h
4015
4254
  result = {}
4016
- result["r".to_sym] = @r
4017
- result["g".to_sym] = @g
4018
- result["b".to_sym] = @b
4255
+
4256
+ result[:"r"] = @r
4257
+ result[:"g"] = @g
4258
+ result[:"b"] = @b
4259
+
4260
+ result
4261
+ end
4262
+
4263
+ def as_json(options = {})
4264
+ result = {}
4265
+
4266
+ result["r"] = @r if !options[:compact] || has_r?
4267
+ result["g"] = @g if !options[:compact] || has_g?
4268
+ result["b"] = @b if !options[:compact] || has_b?
4269
+
4019
4270
  result
4020
4271
  end
4272
+
4273
+ def to_json(as_json_options = {})
4274
+ require "json"
4275
+ JSON.dump(as_json(as_json_options))
4276
+ end
4021
4277
  end
4022
4278
  class DebugText
4023
4279
  def self.decode(buff)
@@ -4215,20 +4471,39 @@ module Api
4215
4471
  # unexpected, so discard it and continue.
4216
4472
  if !found
4217
4473
  wire_type = tag & 0x7
4474
+
4475
+ unknown_bytes = +"".b
4476
+ val = tag
4477
+ loop do
4478
+ byte = val & 0x7F
4479
+
4480
+ val >>= 7
4481
+ # This drops the top bits,
4482
+ # Otherwise, with a signed right shift,
4483
+ # we get infinity one bits at the top
4484
+ val &= (1 << 57) - 1
4485
+
4486
+ byte |= 0x80 if val != 0
4487
+ unknown_bytes << byte
4488
+ break if val == 0
4489
+ end
4490
+
4218
4491
  case wire_type
4219
4492
  when 0
4220
4493
  i = 0
4221
4494
  while true
4222
4495
  newbyte = buff.getbyte(index)
4223
4496
  index += 1
4224
- break if newbyte.nil? || newbyte < 0x80
4497
+ break if newbyte.nil?
4498
+ unknown_bytes << newbyte
4499
+ break if newbyte < 0x80
4225
4500
  i += 1
4226
4501
  break if i > 9
4227
4502
  end
4228
4503
  when 1
4504
+ unknown_bytes << buff.byteslice(index, 8)
4229
4505
  index += 8
4230
4506
  when 2
4231
- ## PULL_BYTES
4232
4507
  value =
4233
4508
  if (byte0 = buff.getbyte(index)) < 0x80
4234
4509
  index += 1
@@ -4284,15 +4559,30 @@ module Api
4284
4559
  raise "integer decoding error"
4285
4560
  end
4286
4561
 
4287
- buff.byteslice(index, value)
4288
- index += value
4562
+ val = value
4563
+ loop do
4564
+ byte = val & 0x7F
4565
+
4566
+ val >>= 7
4567
+ # This drops the top bits,
4568
+ # Otherwise, with a signed right shift,
4569
+ # we get infinity one bits at the top
4570
+ val &= (1 << 57) - 1
4571
+
4572
+ byte |= 0x80 if val != 0
4573
+ unknown_bytes << byte
4574
+ break if val == 0
4575
+ end
4289
4576
 
4290
- ## END PULL_BYTES
4577
+ unknown_bytes << buff.byteslice(index, value)
4578
+ index += value
4291
4579
  when 5
4580
+ unknown_bytes << buff.byteslice(index, 4)
4292
4581
  index += 4
4293
4582
  else
4294
4583
  raise "unknown wire type #{wire_type}"
4295
4584
  end
4585
+ (@_unknown_fields ||= +"".b) << unknown_bytes
4296
4586
  return self if index >= len
4297
4587
  ## PULL_UINT64
4298
4588
  tag =
@@ -4960,13 +5250,14 @@ module Api
4960
5250
  end
4961
5251
 
4962
5252
  val = @text
4963
- if ((len = val.bytesize) > 0)
5253
+ if (len = val.bytesize) > 0 || has_text?
4964
5254
  buff << 0x12
4965
- while len != 0
5255
+ loop do
4966
5256
  byte = len & 0x7F
4967
5257
  len >>= 7
4968
5258
  byte |= 0x80 if len > 0
4969
5259
  buff << byte
5260
+ break if len == 0
4970
5261
  end
4971
5262
 
4972
5263
  buff << (val.ascii_only? ? val : val.b)
@@ -5069,29 +5360,63 @@ module Api
5069
5360
  end
5070
5361
 
5071
5362
  val = @size
5072
- if val != 0
5363
+ if has_size?
5073
5364
  buff << 0x28
5074
5365
 
5075
- while val != 0
5366
+ loop do
5076
5367
  byte = val & 0x7F
5077
5368
  val >>= 7
5078
5369
  byte |= 0x80 if val > 0
5079
5370
  buff << byte
5371
+ break if val == 0
5080
5372
  end
5081
5373
  end
5082
-
5374
+ buff << @_unknown_fields if @_unknown_fields
5083
5375
  buff
5084
5376
  end
5085
5377
 
5086
5378
  def to_h
5087
5379
  result = {}
5088
- result["color".to_sym] = @color.to_h
5089
- result["text".to_sym] = @text
5090
- result["virtual_pos".to_sym] = @virtual_pos.to_h
5091
- result["world_pos".to_sym] = @world_pos.to_h
5092
- result["size".to_sym] = @size
5380
+
5381
+ result[:"color"] = @color.to_h
5382
+ result[:"text"] = @text
5383
+ result[:"virtual_pos"] = @virtual_pos.to_h
5384
+ result[:"world_pos"] = @world_pos.to_h
5385
+ result[:"size"] = @size
5386
+
5387
+ result
5388
+ end
5389
+
5390
+ def as_json(options = {})
5391
+ result = {}
5392
+
5393
+ result["color"] = @color.nil? ? {} : @color.as_json(options) if !options[
5394
+ :compact
5395
+ ] || has_color?
5396
+ result["text"] = @text if !options[:compact] || has_text?
5397
+ result["virtualPos"] = (
5398
+ if @virtual_pos.nil?
5399
+ {}
5400
+ else
5401
+ @virtual_pos.as_json(options)
5402
+ end
5403
+ ) if !options[:compact] || has_virtual_pos?
5404
+ result["worldPos"] = (
5405
+ if @world_pos.nil?
5406
+ {}
5407
+ else
5408
+ @world_pos.as_json(options)
5409
+ end
5410
+ ) if !options[:compact] || has_world_pos?
5411
+ result["size"] = @size if !options[:compact] || has_size?
5412
+
5093
5413
  result
5094
5414
  end
5415
+
5416
+ def to_json(as_json_options = {})
5417
+ require "json"
5418
+ JSON.dump(as_json(as_json_options))
5419
+ end
5095
5420
  end
5096
5421
  class DebugLine
5097
5422
  def self.decode(buff)
@@ -5217,20 +5542,39 @@ module Api
5217
5542
  # unexpected, so discard it and continue.
5218
5543
  if !found
5219
5544
  wire_type = tag & 0x7
5545
+
5546
+ unknown_bytes = +"".b
5547
+ val = tag
5548
+ loop do
5549
+ byte = val & 0x7F
5550
+
5551
+ val >>= 7
5552
+ # This drops the top bits,
5553
+ # Otherwise, with a signed right shift,
5554
+ # we get infinity one bits at the top
5555
+ val &= (1 << 57) - 1
5556
+
5557
+ byte |= 0x80 if val != 0
5558
+ unknown_bytes << byte
5559
+ break if val == 0
5560
+ end
5561
+
5220
5562
  case wire_type
5221
5563
  when 0
5222
5564
  i = 0
5223
5565
  while true
5224
5566
  newbyte = buff.getbyte(index)
5225
5567
  index += 1
5226
- break if newbyte.nil? || newbyte < 0x80
5568
+ break if newbyte.nil?
5569
+ unknown_bytes << newbyte
5570
+ break if newbyte < 0x80
5227
5571
  i += 1
5228
5572
  break if i > 9
5229
5573
  end
5230
5574
  when 1
5575
+ unknown_bytes << buff.byteslice(index, 8)
5231
5576
  index += 8
5232
5577
  when 2
5233
- ## PULL_BYTES
5234
5578
  value =
5235
5579
  if (byte0 = buff.getbyte(index)) < 0x80
5236
5580
  index += 1
@@ -5286,15 +5630,30 @@ module Api
5286
5630
  raise "integer decoding error"
5287
5631
  end
5288
5632
 
5289
- buff.byteslice(index, value)
5290
- index += value
5633
+ val = value
5634
+ loop do
5635
+ byte = val & 0x7F
5636
+
5637
+ val >>= 7
5638
+ # This drops the top bits,
5639
+ # Otherwise, with a signed right shift,
5640
+ # we get infinity one bits at the top
5641
+ val &= (1 << 57) - 1
5642
+
5643
+ byte |= 0x80 if val != 0
5644
+ unknown_bytes << byte
5645
+ break if val == 0
5646
+ end
5291
5647
 
5292
- ## END PULL_BYTES
5648
+ unknown_bytes << buff.byteslice(index, value)
5649
+ index += value
5293
5650
  when 5
5651
+ unknown_bytes << buff.byteslice(index, 4)
5294
5652
  index += 4
5295
5653
  else
5296
5654
  raise "unknown wire type #{wire_type}"
5297
5655
  end
5656
+ (@_unknown_fields ||= +"".b) << unknown_bytes
5298
5657
  return self if index >= len
5299
5658
  ## PULL_UINT64
5300
5659
  tag =
@@ -5675,16 +6034,36 @@ module Api
5675
6034
 
5676
6035
  buff
5677
6036
  end
5678
-
6037
+ buff << @_unknown_fields if @_unknown_fields
5679
6038
  buff
5680
6039
  end
5681
6040
 
5682
6041
  def to_h
5683
6042
  result = {}
5684
- result["color".to_sym] = @color.to_h
5685
- result["line".to_sym] = @line.to_h
6043
+
6044
+ result[:"color"] = @color.to_h
6045
+ result[:"line"] = @line.to_h
6046
+
6047
+ result
6048
+ end
6049
+
6050
+ def as_json(options = {})
6051
+ result = {}
6052
+
6053
+ result["color"] = @color.nil? ? {} : @color.as_json(options) if !options[
6054
+ :compact
6055
+ ] || has_color?
6056
+ result["line"] = @line.nil? ? {} : @line.as_json(options) if !options[
6057
+ :compact
6058
+ ] || has_line?
6059
+
5686
6060
  result
5687
6061
  end
6062
+
6063
+ def to_json(as_json_options = {})
6064
+ require "json"
6065
+ JSON.dump(as_json(as_json_options))
6066
+ end
5688
6067
  end
5689
6068
  class DebugBox
5690
6069
  def self.decode(buff)
@@ -5829,20 +6208,39 @@ module Api
5829
6208
  # unexpected, so discard it and continue.
5830
6209
  if !found
5831
6210
  wire_type = tag & 0x7
6211
+
6212
+ unknown_bytes = +"".b
6213
+ val = tag
6214
+ loop do
6215
+ byte = val & 0x7F
6216
+
6217
+ val >>= 7
6218
+ # This drops the top bits,
6219
+ # Otherwise, with a signed right shift,
6220
+ # we get infinity one bits at the top
6221
+ val &= (1 << 57) - 1
6222
+
6223
+ byte |= 0x80 if val != 0
6224
+ unknown_bytes << byte
6225
+ break if val == 0
6226
+ end
6227
+
5832
6228
  case wire_type
5833
6229
  when 0
5834
6230
  i = 0
5835
6231
  while true
5836
6232
  newbyte = buff.getbyte(index)
5837
6233
  index += 1
5838
- break if newbyte.nil? || newbyte < 0x80
6234
+ break if newbyte.nil?
6235
+ unknown_bytes << newbyte
6236
+ break if newbyte < 0x80
5839
6237
  i += 1
5840
6238
  break if i > 9
5841
6239
  end
5842
6240
  when 1
6241
+ unknown_bytes << buff.byteslice(index, 8)
5843
6242
  index += 8
5844
6243
  when 2
5845
- ## PULL_BYTES
5846
6244
  value =
5847
6245
  if (byte0 = buff.getbyte(index)) < 0x80
5848
6246
  index += 1
@@ -5898,15 +6296,30 @@ module Api
5898
6296
  raise "integer decoding error"
5899
6297
  end
5900
6298
 
5901
- buff.byteslice(index, value)
5902
- index += value
6299
+ val = value
6300
+ loop do
6301
+ byte = val & 0x7F
5903
6302
 
5904
- ## END PULL_BYTES
6303
+ val >>= 7
6304
+ # This drops the top bits,
6305
+ # Otherwise, with a signed right shift,
6306
+ # we get infinity one bits at the top
6307
+ val &= (1 << 57) - 1
6308
+
6309
+ byte |= 0x80 if val != 0
6310
+ unknown_bytes << byte
6311
+ break if val == 0
6312
+ end
6313
+
6314
+ unknown_bytes << buff.byteslice(index, value)
6315
+ index += value
5905
6316
  when 5
6317
+ unknown_bytes << buff.byteslice(index, 4)
5906
6318
  index += 4
5907
6319
  else
5908
6320
  raise "unknown wire type #{wire_type}"
5909
6321
  end
6322
+ (@_unknown_fields ||= +"".b) << unknown_bytes
5910
6323
  return self if index >= len
5911
6324
  ## PULL_UINT64
5912
6325
  tag =
@@ -6447,17 +6860,40 @@ module Api
6447
6860
 
6448
6861
  buff
6449
6862
  end
6450
-
6863
+ buff << @_unknown_fields if @_unknown_fields
6451
6864
  buff
6452
6865
  end
6453
6866
 
6454
6867
  def to_h
6455
6868
  result = {}
6456
- result["color".to_sym] = @color.to_h
6457
- result["min".to_sym] = @min.to_h
6458
- result["max".to_sym] = @max.to_h
6869
+
6870
+ result[:"color"] = @color.to_h
6871
+ result[:"min"] = @min.to_h
6872
+ result[:"max"] = @max.to_h
6873
+
6874
+ result
6875
+ end
6876
+
6877
+ def as_json(options = {})
6878
+ result = {}
6879
+
6880
+ result["color"] = @color.nil? ? {} : @color.as_json(options) if !options[
6881
+ :compact
6882
+ ] || has_color?
6883
+ result["min"] = @min.nil? ? {} : @min.as_json(options) if !options[
6884
+ :compact
6885
+ ] || has_min?
6886
+ result["max"] = @max.nil? ? {} : @max.as_json(options) if !options[
6887
+ :compact
6888
+ ] || has_max?
6889
+
6459
6890
  result
6460
6891
  end
6892
+
6893
+ def to_json(as_json_options = {})
6894
+ require "json"
6895
+ JSON.dump(as_json(as_json_options))
6896
+ end
6461
6897
  end
6462
6898
  class DebugSphere
6463
6899
  def self.decode(buff)
@@ -6602,20 +7038,39 @@ module Api
6602
7038
  # unexpected, so discard it and continue.
6603
7039
  if !found
6604
7040
  wire_type = tag & 0x7
7041
+
7042
+ unknown_bytes = +"".b
7043
+ val = tag
7044
+ loop do
7045
+ byte = val & 0x7F
7046
+
7047
+ val >>= 7
7048
+ # This drops the top bits,
7049
+ # Otherwise, with a signed right shift,
7050
+ # we get infinity one bits at the top
7051
+ val &= (1 << 57) - 1
7052
+
7053
+ byte |= 0x80 if val != 0
7054
+ unknown_bytes << byte
7055
+ break if val == 0
7056
+ end
7057
+
6605
7058
  case wire_type
6606
7059
  when 0
6607
7060
  i = 0
6608
7061
  while true
6609
7062
  newbyte = buff.getbyte(index)
6610
7063
  index += 1
6611
- break if newbyte.nil? || newbyte < 0x80
7064
+ break if newbyte.nil?
7065
+ unknown_bytes << newbyte
7066
+ break if newbyte < 0x80
6612
7067
  i += 1
6613
7068
  break if i > 9
6614
7069
  end
6615
7070
  when 1
7071
+ unknown_bytes << buff.byteslice(index, 8)
6616
7072
  index += 8
6617
7073
  when 2
6618
- ## PULL_BYTES
6619
7074
  value =
6620
7075
  if (byte0 = buff.getbyte(index)) < 0x80
6621
7076
  index += 1
@@ -6671,15 +7126,30 @@ module Api
6671
7126
  raise "integer decoding error"
6672
7127
  end
6673
7128
 
6674
- buff.byteslice(index, value)
6675
- index += value
7129
+ val = value
7130
+ loop do
7131
+ byte = val & 0x7F
7132
+
7133
+ val >>= 7
7134
+ # This drops the top bits,
7135
+ # Otherwise, with a signed right shift,
7136
+ # we get infinity one bits at the top
7137
+ val &= (1 << 57) - 1
7138
+
7139
+ byte |= 0x80 if val != 0
7140
+ unknown_bytes << byte
7141
+ break if val == 0
7142
+ end
6676
7143
 
6677
- ## END PULL_BYTES
7144
+ unknown_bytes << buff.byteslice(index, value)
7145
+ index += value
6678
7146
  when 5
7147
+ unknown_bytes << buff.byteslice(index, 4)
6679
7148
  index += 4
6680
7149
  else
6681
7150
  raise "unknown wire type #{wire_type}"
6682
7151
  end
7152
+ (@_unknown_fields ||= +"".b) << unknown_bytes
6683
7153
  return self if index >= len
6684
7154
  ## PULL_UINT64
6685
7155
  tag =
@@ -7120,22 +7590,42 @@ module Api
7120
7590
  end
7121
7591
 
7122
7592
  val = @r
7123
- if val != 0
7593
+ if has_r?
7124
7594
  buff << 0x1d
7125
7595
 
7126
7596
  [val].pack("e", buffer: buff)
7127
7597
  end
7128
-
7598
+ buff << @_unknown_fields if @_unknown_fields
7129
7599
  buff
7130
7600
  end
7131
7601
 
7132
7602
  def to_h
7133
7603
  result = {}
7134
- result["color".to_sym] = @color.to_h
7135
- result["p".to_sym] = @p.to_h
7136
- result["r".to_sym] = @r
7604
+
7605
+ result[:"color"] = @color.to_h
7606
+ result[:"p"] = @p.to_h
7607
+ result[:"r"] = @r
7608
+
7609
+ result
7610
+ end
7611
+
7612
+ def as_json(options = {})
7613
+ result = {}
7614
+
7615
+ result["color"] = @color.nil? ? {} : @color.as_json(options) if !options[
7616
+ :compact
7617
+ ] || has_color?
7618
+ result["p"] = @p.nil? ? {} : @p.as_json(options) if !options[:compact] ||
7619
+ has_p?
7620
+ result["r"] = @r if !options[:compact] || has_r?
7621
+
7137
7622
  result
7138
7623
  end
7624
+
7625
+ def to_json(as_json_options = {})
7626
+ require "json"
7627
+ JSON.dump(as_json(as_json_options))
7628
+ end
7139
7629
  end
7140
7630
  class DebugCreateUnit
7141
7631
  def self.decode(buff)
@@ -7326,20 +7816,39 @@ module Api
7326
7816
  # unexpected, so discard it and continue.
7327
7817
  if !found
7328
7818
  wire_type = tag & 0x7
7819
+
7820
+ unknown_bytes = +"".b
7821
+ val = tag
7822
+ loop do
7823
+ byte = val & 0x7F
7824
+
7825
+ val >>= 7
7826
+ # This drops the top bits,
7827
+ # Otherwise, with a signed right shift,
7828
+ # we get infinity one bits at the top
7829
+ val &= (1 << 57) - 1
7830
+
7831
+ byte |= 0x80 if val != 0
7832
+ unknown_bytes << byte
7833
+ break if val == 0
7834
+ end
7835
+
7329
7836
  case wire_type
7330
7837
  when 0
7331
7838
  i = 0
7332
7839
  while true
7333
7840
  newbyte = buff.getbyte(index)
7334
7841
  index += 1
7335
- break if newbyte.nil? || newbyte < 0x80
7842
+ break if newbyte.nil?
7843
+ unknown_bytes << newbyte
7844
+ break if newbyte < 0x80
7336
7845
  i += 1
7337
7846
  break if i > 9
7338
7847
  end
7339
7848
  when 1
7849
+ unknown_bytes << buff.byteslice(index, 8)
7340
7850
  index += 8
7341
7851
  when 2
7342
- ## PULL_BYTES
7343
7852
  value =
7344
7853
  if (byte0 = buff.getbyte(index)) < 0x80
7345
7854
  index += 1
@@ -7395,15 +7904,30 @@ module Api
7395
7904
  raise "integer decoding error"
7396
7905
  end
7397
7906
 
7398
- buff.byteslice(index, value)
7399
- index += value
7907
+ val = value
7908
+ loop do
7909
+ byte = val & 0x7F
7910
+
7911
+ val >>= 7
7912
+ # This drops the top bits,
7913
+ # Otherwise, with a signed right shift,
7914
+ # we get infinity one bits at the top
7915
+ val &= (1 << 57) - 1
7916
+
7917
+ byte |= 0x80 if val != 0
7918
+ unknown_bytes << byte
7919
+ break if val == 0
7920
+ end
7400
7921
 
7401
- ## END PULL_BYTES
7922
+ unknown_bytes << buff.byteslice(index, value)
7923
+ index += value
7402
7924
  when 5
7925
+ unknown_bytes << buff.byteslice(index, 4)
7403
7926
  index += 4
7404
7927
  else
7405
7928
  raise "unknown wire type #{wire_type}"
7406
7929
  end
7930
+ (@_unknown_fields ||= +"".b) << unknown_bytes
7407
7931
  return self if index >= len
7408
7932
  ## PULL_UINT64
7409
7933
  tag =
@@ -7914,22 +8438,23 @@ module Api
7914
8438
  end
7915
8439
  def _encode(buff)
7916
8440
  val = @unit_type
7917
- if val != 0
8441
+ if has_unit_type?
7918
8442
  buff << 0x08
7919
8443
 
7920
- while val != 0
8444
+ loop do
7921
8445
  byte = val & 0x7F
7922
8446
  val >>= 7
7923
8447
  byte |= 0x80 if val > 0
7924
8448
  buff << byte
8449
+ break if val == 0
7925
8450
  end
7926
8451
  end
7927
8452
 
7928
8453
  val = @owner
7929
- if val != 0
8454
+ if has_owner?
7930
8455
  buff << 0x10
7931
8456
 
7932
- while val != 0
8457
+ loop do
7933
8458
  byte = val & 0x7F
7934
8459
 
7935
8460
  val >>= 7
@@ -7940,6 +8465,7 @@ module Api
7940
8465
 
7941
8466
  byte |= 0x80 if val != 0
7942
8467
  buff << byte
8468
+ break if val == 0
7943
8469
  end
7944
8470
  end
7945
8471
 
@@ -7992,28 +8518,49 @@ module Api
7992
8518
  end
7993
8519
 
7994
8520
  val = @quantity
7995
- if val != 0
8521
+ if has_quantity?
7996
8522
  buff << 0x20
7997
8523
 
7998
- while val != 0
8524
+ loop do
7999
8525
  byte = val & 0x7F
8000
8526
  val >>= 7
8001
8527
  byte |= 0x80 if val > 0
8002
8528
  buff << byte
8529
+ break if val == 0
8003
8530
  end
8004
8531
  end
8005
-
8532
+ buff << @_unknown_fields if @_unknown_fields
8006
8533
  buff
8007
8534
  end
8008
8535
 
8009
8536
  def to_h
8010
8537
  result = {}
8011
- result["unit_type".to_sym] = @unit_type
8012
- result["owner".to_sym] = @owner
8013
- result["pos".to_sym] = @pos.to_h
8014
- result["quantity".to_sym] = @quantity
8538
+
8539
+ result[:"unit_type"] = @unit_type
8540
+ result[:"owner"] = @owner
8541
+ result[:"pos"] = @pos.to_h
8542
+ result[:"quantity"] = @quantity
8543
+
8544
+ result
8545
+ end
8546
+
8547
+ def as_json(options = {})
8548
+ result = {}
8549
+
8550
+ result["unitType"] = @unit_type if !options[:compact] || has_unit_type?
8551
+ result["owner"] = @owner if !options[:compact] || has_owner?
8552
+ result["pos"] = @pos.nil? ? {} : @pos.as_json(options) if !options[
8553
+ :compact
8554
+ ] || has_pos?
8555
+ result["quantity"] = @quantity if !options[:compact] || has_quantity?
8556
+
8015
8557
  result
8016
8558
  end
8559
+
8560
+ def to_json(as_json_options = {})
8561
+ require "json"
8562
+ JSON.dump(as_json(as_json_options))
8563
+ end
8017
8564
  end
8018
8565
  class DebugKillUnit
8019
8566
  def self.decode(buff)
@@ -8114,20 +8661,39 @@ module Api
8114
8661
  # unexpected, so discard it and continue.
8115
8662
  if !found
8116
8663
  wire_type = tag & 0x7
8664
+
8665
+ unknown_bytes = +"".b
8666
+ val = tag
8667
+ loop do
8668
+ byte = val & 0x7F
8669
+
8670
+ val >>= 7
8671
+ # This drops the top bits,
8672
+ # Otherwise, with a signed right shift,
8673
+ # we get infinity one bits at the top
8674
+ val &= (1 << 57) - 1
8675
+
8676
+ byte |= 0x80 if val != 0
8677
+ unknown_bytes << byte
8678
+ break if val == 0
8679
+ end
8680
+
8117
8681
  case wire_type
8118
8682
  when 0
8119
8683
  i = 0
8120
8684
  while true
8121
8685
  newbyte = buff.getbyte(index)
8122
8686
  index += 1
8123
- break if newbyte.nil? || newbyte < 0x80
8687
+ break if newbyte.nil?
8688
+ unknown_bytes << newbyte
8689
+ break if newbyte < 0x80
8124
8690
  i += 1
8125
8691
  break if i > 9
8126
8692
  end
8127
8693
  when 1
8694
+ unknown_bytes << buff.byteslice(index, 8)
8128
8695
  index += 8
8129
8696
  when 2
8130
- ## PULL_BYTES
8131
8697
  value =
8132
8698
  if (byte0 = buff.getbyte(index)) < 0x80
8133
8699
  index += 1
@@ -8183,15 +8749,30 @@ module Api
8183
8749
  raise "integer decoding error"
8184
8750
  end
8185
8751
 
8186
- buff.byteslice(index, value)
8187
- index += value
8752
+ val = value
8753
+ loop do
8754
+ byte = val & 0x7F
8755
+
8756
+ val >>= 7
8757
+ # This drops the top bits,
8758
+ # Otherwise, with a signed right shift,
8759
+ # we get infinity one bits at the top
8760
+ val &= (1 << 57) - 1
8761
+
8762
+ byte |= 0x80 if val != 0
8763
+ unknown_bytes << byte
8764
+ break if val == 0
8765
+ end
8188
8766
 
8189
- ## END PULL_BYTES
8767
+ unknown_bytes << buff.byteslice(index, value)
8768
+ index += value
8190
8769
  when 5
8770
+ unknown_bytes << buff.byteslice(index, 4)
8191
8771
  index += 4
8192
8772
  else
8193
8773
  raise "unknown wire type #{wire_type}"
8194
8774
  end
8775
+ (@_unknown_fields ||= +"".b) << unknown_bytes
8195
8776
  return self if index >= len
8196
8777
  ## PULL_UINT64
8197
8778
  tag =
@@ -8247,11 +8828,13 @@ module Api
8247
8828
  end
8248
8829
  found = false
8249
8830
 
8250
- if tag == 0xa
8831
+ if tag == 0x8
8251
8832
  found = true
8252
- ## PULL_UINT64
8253
- value =
8254
- if (byte0 = buff.getbyte(index)) < 0x80
8833
+ ## DECODE REPEATED
8834
+ list = @tag
8835
+ while true
8836
+ ## PULL_UINT64
8837
+ list << if (byte0 = buff.getbyte(index)) < 0x80
8255
8838
  index += 1
8256
8839
  byte0
8257
8840
  elsif (byte1 = buff.getbyte(index + 1)) < 0x80
@@ -8299,116 +8882,72 @@ module Api
8299
8882
  raise "integer decoding error"
8300
8883
  end
8301
8884
 
8302
- ## END PULL_UINT64
8885
+ ## END PULL_UINT64
8303
8886
 
8304
- goal = index + value
8305
- list = @tag
8306
- while true
8307
- break if index >= goal
8887
+ return self if index >= len
8308
8888
  ## PULL_UINT64
8309
- list << if (byte0 = buff.getbyte(index)) < 0x80
8310
- index += 1
8311
- byte0
8312
- elsif (byte1 = buff.getbyte(index + 1)) < 0x80
8313
- index += 2
8314
- (byte1 << 7) | (byte0 & 0x7F)
8315
- elsif (byte2 = buff.getbyte(index + 2)) < 0x80
8316
- index += 3
8317
- (byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
8318
- elsif (byte3 = buff.getbyte(index + 3)) < 0x80
8319
- index += 4
8320
- (byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
8321
- (byte0 & 0x7F)
8322
- elsif (byte4 = buff.getbyte(index + 4)) < 0x80
8323
- index += 5
8324
- (byte4 << 28) | ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
8325
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
8326
- elsif (byte5 = buff.getbyte(index + 5)) < 0x80
8327
- index += 6
8328
- (byte5 << 35) | ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
8329
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
8330
- elsif (byte6 = buff.getbyte(index + 6)) < 0x80
8331
- index += 7
8332
- (byte6 << 42) | ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
8333
- ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
8334
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
8335
- elsif (byte7 = buff.getbyte(index + 7)) < 0x80
8336
- index += 8
8337
- (byte7 << 49) | ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
8338
- ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
8339
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
8340
- elsif (byte8 = buff.getbyte(index + 8)) < 0x80
8341
- index += 9
8342
- (byte8 << 56) | ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
8343
- ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
8344
- ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
8345
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
8346
- elsif (byte9 = buff.getbyte(index + 9)) < 0x80
8347
- index += 10
8889
+ tag =
8890
+ if (byte0 = buff.getbyte(index)) < 0x80
8891
+ index += 1
8892
+ byte0
8893
+ elsif (byte1 = buff.getbyte(index + 1)) < 0x80
8894
+ index += 2
8895
+ (byte1 << 7) | (byte0 & 0x7F)
8896
+ elsif (byte2 = buff.getbyte(index + 2)) < 0x80
8897
+ index += 3
8898
+ (byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
8899
+ elsif (byte3 = buff.getbyte(index + 3)) < 0x80
8900
+ index += 4
8901
+ (byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
8902
+ (byte0 & 0x7F)
8903
+ elsif (byte4 = buff.getbyte(index + 4)) < 0x80
8904
+ index += 5
8905
+ (byte4 << 28) | ((byte3 & 0x7F) << 21) |
8906
+ ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
8907
+ (byte0 & 0x7F)
8908
+ elsif (byte5 = buff.getbyte(index + 5)) < 0x80
8909
+ index += 6
8910
+ (byte5 << 35) | ((byte4 & 0x7F) << 28) |
8911
+ ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
8912
+ ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
8913
+ elsif (byte6 = buff.getbyte(index + 6)) < 0x80
8914
+ index += 7
8915
+ (byte6 << 42) | ((byte5 & 0x7F) << 35) |
8916
+ ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
8917
+ ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
8918
+ (byte0 & 0x7F)
8919
+ elsif (byte7 = buff.getbyte(index + 7)) < 0x80
8920
+ index += 8
8921
+ (byte7 << 49) | ((byte6 & 0x7F) << 42) |
8922
+ ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
8923
+ ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
8924
+ ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
8925
+ elsif (byte8 = buff.getbyte(index + 8)) < 0x80
8926
+ index += 9
8927
+ (byte8 << 56) | ((byte7 & 0x7F) << 49) |
8928
+ ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
8929
+ ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
8930
+ ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
8931
+ (byte0 & 0x7F)
8932
+ elsif (byte9 = buff.getbyte(index + 9)) < 0x80
8933
+ index += 10
8348
8934
 
8349
- (byte9 << 63) | ((byte8 & 0x7F) << 56) | ((byte7 & 0x7F) << 49) |
8350
- ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
8351
- ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
8352
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
8353
- else
8354
- raise "integer decoding error"
8355
- end
8935
+ (byte9 << 63) | ((byte8 & 0x7F) << 56) |
8936
+ ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
8937
+ ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
8938
+ ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
8939
+ ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
8940
+ else
8941
+ raise "integer decoding error"
8942
+ end
8356
8943
 
8357
8944
  ## END PULL_UINT64
8945
+
8946
+ break unless tag == 0x8
8358
8947
  end
8948
+ ## END DECODE REPEATED
8359
8949
 
8360
8950
  return self if index >= len
8361
- ## PULL_UINT64
8362
- tag =
8363
- if (byte0 = buff.getbyte(index)) < 0x80
8364
- index += 1
8365
- byte0
8366
- elsif (byte1 = buff.getbyte(index + 1)) < 0x80
8367
- index += 2
8368
- (byte1 << 7) | (byte0 & 0x7F)
8369
- elsif (byte2 = buff.getbyte(index + 2)) < 0x80
8370
- index += 3
8371
- (byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
8372
- elsif (byte3 = buff.getbyte(index + 3)) < 0x80
8373
- index += 4
8374
- (byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
8375
- (byte0 & 0x7F)
8376
- elsif (byte4 = buff.getbyte(index + 4)) < 0x80
8377
- index += 5
8378
- (byte4 << 28) | ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
8379
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
8380
- elsif (byte5 = buff.getbyte(index + 5)) < 0x80
8381
- index += 6
8382
- (byte5 << 35) | ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
8383
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
8384
- elsif (byte6 = buff.getbyte(index + 6)) < 0x80
8385
- index += 7
8386
- (byte6 << 42) | ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
8387
- ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
8388
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
8389
- elsif (byte7 = buff.getbyte(index + 7)) < 0x80
8390
- index += 8
8391
- (byte7 << 49) | ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
8392
- ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
8393
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
8394
- elsif (byte8 = buff.getbyte(index + 8)) < 0x80
8395
- index += 9
8396
- (byte8 << 56) | ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
8397
- ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
8398
- ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
8399
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
8400
- elsif (byte9 = buff.getbyte(index + 9)) < 0x80
8401
- index += 10
8402
-
8403
- (byte9 << 63) | ((byte8 & 0x7F) << 56) | ((byte7 & 0x7F) << 49) |
8404
- ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
8405
- ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
8406
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
8407
- else
8408
- raise "integer decoding error"
8409
- end
8410
-
8411
- ## END PULL_UINT64
8412
8951
  end
8413
8952
 
8414
8953
  return self if index >= len
@@ -8417,69 +8956,46 @@ module Api
8417
8956
  def _encode(buff)
8418
8957
  list = @tag
8419
8958
  if list.size > 0
8420
- buff << 0x0a
8421
-
8422
- # Save the buffer size before appending the repeated bytes
8423
- current_len = buff.bytesize
8424
-
8425
- # Write a single dummy byte to later store encoded length
8426
- buff << 42 # "*"
8427
-
8428
- # write each item
8429
8959
  list.each do |item|
8430
8960
  val = item
8431
8961
  if val != 0
8432
- while val != 0
8962
+ buff << 0x08
8963
+
8964
+ loop do
8433
8965
  byte = val & 0x7F
8434
8966
  val >>= 7
8435
8967
  byte |= 0x80 if val > 0
8436
8968
  buff << byte
8969
+ break if val == 0
8437
8970
  end
8438
8971
  end
8439
8972
  end
8973
+ end
8974
+ buff << @_unknown_fields if @_unknown_fields
8975
+ buff
8976
+ end
8440
8977
 
8441
- # Calculate the submessage's size
8442
- submessage_size = buff.bytesize - current_len - 1
8978
+ def to_h
8979
+ result = {}
8443
8980
 
8444
- # Hope the size fits in one byte
8445
- byte = submessage_size & 0x7F
8446
- submessage_size >>= 7
8447
- byte |= 0x80 if submessage_size > 0
8448
- buff.setbyte(current_len, byte)
8981
+ result[:"tag"] = @tag
8449
8982
 
8450
- # If the sub message was bigger
8451
- if submessage_size > 0
8452
- current_len += 1
8983
+ result
8984
+ end
8453
8985
 
8454
- # compute how much we need to shift
8455
- encoded_int_len = 0
8456
- remaining_size = submessage_size
8457
- while remaining_size != 0
8458
- remaining_size >>= 7
8459
- encoded_int_len += 1
8460
- end
8986
+ def as_json(options = {})
8987
+ result = {}
8461
8988
 
8462
- # Make space in the string with dummy bytes
8463
- buff.bytesplice(current_len, 0, "*********", 0, encoded_int_len)
8989
+ tmp_tag = @tag
8464
8990
 
8465
- # Overwrite the dummy bytes with the encoded length
8466
- while submessage_size != 0
8467
- byte = submessage_size & 0x7F
8468
- submessage_size >>= 7
8469
- byte |= 0x80 if submessage_size > 0
8470
- buff.setbyte(current_len, byte)
8471
- current_len += 1
8472
- end
8473
- end
8474
- end
8991
+ result["tag"] = tmp_tag if !options[:compact] || tmp_tag.any?
8475
8992
 
8476
- buff
8993
+ result
8477
8994
  end
8478
8995
 
8479
- def to_h
8480
- result = {}
8481
- result["tag".to_sym] = @tag
8482
- result
8996
+ def to_json(as_json_options = {})
8997
+ require "json"
8998
+ JSON.dump(as_json(as_json_options))
8483
8999
  end
8484
9000
  end
8485
9001
  class DebugTestProcess
@@ -8497,27 +9013,17 @@ module Api
8497
9013
  EXIT = 3
8498
9014
 
8499
9015
  def self.lookup(val)
8500
- if val == 0
8501
- :ENUM_TEST_UNSET
8502
- elsif val == 1
8503
- :HANG
8504
- elsif val == 2
8505
- :CRASH
8506
- elsif val == 3
8507
- :EXIT
8508
- end
9016
+ return :ENUM_TEST_UNSET if val == 0
9017
+ return :HANG if val == 1
9018
+ return :CRASH if val == 2
9019
+ return :EXIT if val == 3
8509
9020
  end
8510
9021
 
8511
9022
  def self.resolve(val)
8512
- if val == :ENUM_TEST_UNSET
8513
- 0
8514
- elsif val == :HANG
8515
- 1
8516
- elsif val == :CRASH
8517
- 2
8518
- elsif val == :EXIT
8519
- 3
8520
- end
9023
+ return 0 if val == :ENUM_TEST_UNSET
9024
+ return 1 if val == :HANG
9025
+ return 2 if val == :CRASH
9026
+ return 3 if val == :EXIT
8521
9027
  end
8522
9028
  end
8523
9029
  # required field readers
@@ -8533,6 +9039,7 @@ module Api
8533
9039
  # enum writers
8534
9040
  def test=(v)
8535
9041
  @test = Api::DebugTestProcess::Test.resolve(v) || v
9042
+ @_bitmask |= 0x0000000000000001
8536
9043
  end
8537
9044
 
8538
9045
  # BEGIN writers for optional fields
@@ -8574,6 +9081,10 @@ module Api
8574
9081
  self.class.encode(self)
8575
9082
  end
8576
9083
 
9084
+ def has_test?
9085
+ (@_bitmask & 0x0000000000000001) == 0x0000000000000001
9086
+ end
9087
+
8577
9088
  def has_delay_ms?
8578
9089
  (@_bitmask & 0x0000000000000002) == 0x0000000000000002
8579
9090
  end
@@ -8643,20 +9154,39 @@ module Api
8643
9154
  # unexpected, so discard it and continue.
8644
9155
  if !found
8645
9156
  wire_type = tag & 0x7
9157
+
9158
+ unknown_bytes = +"".b
9159
+ val = tag
9160
+ loop do
9161
+ byte = val & 0x7F
9162
+
9163
+ val >>= 7
9164
+ # This drops the top bits,
9165
+ # Otherwise, with a signed right shift,
9166
+ # we get infinity one bits at the top
9167
+ val &= (1 << 57) - 1
9168
+
9169
+ byte |= 0x80 if val != 0
9170
+ unknown_bytes << byte
9171
+ break if val == 0
9172
+ end
9173
+
8646
9174
  case wire_type
8647
9175
  when 0
8648
9176
  i = 0
8649
9177
  while true
8650
9178
  newbyte = buff.getbyte(index)
8651
9179
  index += 1
8652
- break if newbyte.nil? || newbyte < 0x80
9180
+ break if newbyte.nil?
9181
+ unknown_bytes << newbyte
9182
+ break if newbyte < 0x80
8653
9183
  i += 1
8654
9184
  break if i > 9
8655
9185
  end
8656
9186
  when 1
9187
+ unknown_bytes << buff.byteslice(index, 8)
8657
9188
  index += 8
8658
9189
  when 2
8659
- ## PULL_BYTES
8660
9190
  value =
8661
9191
  if (byte0 = buff.getbyte(index)) < 0x80
8662
9192
  index += 1
@@ -8712,15 +9242,30 @@ module Api
8712
9242
  raise "integer decoding error"
8713
9243
  end
8714
9244
 
8715
- buff.byteslice(index, value)
8716
- index += value
9245
+ val = value
9246
+ loop do
9247
+ byte = val & 0x7F
9248
+
9249
+ val >>= 7
9250
+ # This drops the top bits,
9251
+ # Otherwise, with a signed right shift,
9252
+ # we get infinity one bits at the top
9253
+ val &= (1 << 57) - 1
9254
+
9255
+ byte |= 0x80 if val != 0
9256
+ unknown_bytes << byte
9257
+ break if val == 0
9258
+ end
8717
9259
 
8718
- ## END PULL_BYTES
9260
+ unknown_bytes << buff.byteslice(index, value)
9261
+ index += value
8719
9262
  when 5
9263
+ unknown_bytes << buff.byteslice(index, 4)
8720
9264
  index += 4
8721
9265
  else
8722
9266
  raise "unknown wire type #{wire_type}"
8723
9267
  end
9268
+ (@_unknown_fields ||= +"".b) << unknown_bytes
8724
9269
  return self if index >= len
8725
9270
  ## PULL_UINT64
8726
9271
  tag =
@@ -9022,10 +9567,10 @@ module Api
9022
9567
  end
9023
9568
  def _encode(buff)
9024
9569
  val = @test
9025
- if val != 0
9570
+ if has_test?
9026
9571
  buff << 0x08
9027
9572
 
9028
- while val != 0
9573
+ loop do
9029
9574
  byte = val & 0x7F
9030
9575
 
9031
9576
  val >>= 7
@@ -9036,14 +9581,15 @@ module Api
9036
9581
 
9037
9582
  byte |= 0x80 if val != 0
9038
9583
  buff << byte
9584
+ break if val == 0
9039
9585
  end
9040
9586
  end
9041
9587
 
9042
9588
  val = @delay_ms
9043
- if val != 0
9589
+ if has_delay_ms?
9044
9590
  buff << 0x10
9045
9591
 
9046
- while val != 0
9592
+ loop do
9047
9593
  byte = val & 0x7F
9048
9594
 
9049
9595
  val >>= 7
@@ -9054,18 +9600,35 @@ module Api
9054
9600
 
9055
9601
  byte |= 0x80 if val != 0
9056
9602
  buff << byte
9603
+ break if val == 0
9057
9604
  end
9058
9605
  end
9059
-
9606
+ buff << @_unknown_fields if @_unknown_fields
9060
9607
  buff
9061
9608
  end
9062
9609
 
9063
9610
  def to_h
9064
9611
  result = {}
9065
- result["test".to_sym] = @test
9066
- result["delay_ms".to_sym] = @delay_ms
9612
+
9613
+ result[:"test"] = @test
9614
+ result[:"delay_ms"] = @delay_ms
9615
+
9616
+ result
9617
+ end
9618
+
9619
+ def as_json(options = {})
9620
+ result = {}
9621
+
9622
+ result["test"] = @test if !options[:compact] || has_test?
9623
+ result["delayMs"] = @delay_ms if !options[:compact] || has_delay_ms?
9624
+
9067
9625
  result
9068
9626
  end
9627
+
9628
+ def to_json(as_json_options = {})
9629
+ require "json"
9630
+ JSON.dump(as_json(as_json_options))
9631
+ end
9069
9632
  end
9070
9633
  class DebugSetScore
9071
9634
  def self.decode(buff)
@@ -9172,20 +9735,39 @@ module Api
9172
9735
  # unexpected, so discard it and continue.
9173
9736
  if !found
9174
9737
  wire_type = tag & 0x7
9738
+
9739
+ unknown_bytes = +"".b
9740
+ val = tag
9741
+ loop do
9742
+ byte = val & 0x7F
9743
+
9744
+ val >>= 7
9745
+ # This drops the top bits,
9746
+ # Otherwise, with a signed right shift,
9747
+ # we get infinity one bits at the top
9748
+ val &= (1 << 57) - 1
9749
+
9750
+ byte |= 0x80 if val != 0
9751
+ unknown_bytes << byte
9752
+ break if val == 0
9753
+ end
9754
+
9175
9755
  case wire_type
9176
9756
  when 0
9177
9757
  i = 0
9178
9758
  while true
9179
9759
  newbyte = buff.getbyte(index)
9180
9760
  index += 1
9181
- break if newbyte.nil? || newbyte < 0x80
9761
+ break if newbyte.nil?
9762
+ unknown_bytes << newbyte
9763
+ break if newbyte < 0x80
9182
9764
  i += 1
9183
9765
  break if i > 9
9184
9766
  end
9185
9767
  when 1
9768
+ unknown_bytes << buff.byteslice(index, 8)
9186
9769
  index += 8
9187
9770
  when 2
9188
- ## PULL_BYTES
9189
9771
  value =
9190
9772
  if (byte0 = buff.getbyte(index)) < 0x80
9191
9773
  index += 1
@@ -9241,15 +9823,30 @@ module Api
9241
9823
  raise "integer decoding error"
9242
9824
  end
9243
9825
 
9244
- buff.byteslice(index, value)
9245
- index += value
9826
+ val = value
9827
+ loop do
9828
+ byte = val & 0x7F
9829
+
9830
+ val >>= 7
9831
+ # This drops the top bits,
9832
+ # Otherwise, with a signed right shift,
9833
+ # we get infinity one bits at the top
9834
+ val &= (1 << 57) - 1
9835
+
9836
+ byte |= 0x80 if val != 0
9837
+ unknown_bytes << byte
9838
+ break if val == 0
9839
+ end
9246
9840
 
9247
- ## END PULL_BYTES
9841
+ unknown_bytes << buff.byteslice(index, value)
9842
+ index += value
9248
9843
  when 5
9844
+ unknown_bytes << buff.byteslice(index, 4)
9249
9845
  index += 4
9250
9846
  else
9251
9847
  raise "unknown wire type #{wire_type}"
9252
9848
  end
9849
+ (@_unknown_fields ||= +"".b) << unknown_bytes
9253
9850
  return self if index >= len
9254
9851
  ## PULL_UINT64
9255
9852
  tag =
@@ -9369,20 +9966,35 @@ module Api
9369
9966
  end
9370
9967
  def _encode(buff)
9371
9968
  val = @score
9372
- if val != 0
9969
+ if has_score?
9373
9970
  buff << 0x0d
9374
9971
 
9375
9972
  [val].pack("e", buffer: buff)
9376
9973
  end
9377
-
9974
+ buff << @_unknown_fields if @_unknown_fields
9378
9975
  buff
9379
9976
  end
9380
9977
 
9381
9978
  def to_h
9382
9979
  result = {}
9383
- result["score".to_sym] = @score
9980
+
9981
+ result[:"score"] = @score
9982
+
9384
9983
  result
9385
9984
  end
9985
+
9986
+ def as_json(options = {})
9987
+ result = {}
9988
+
9989
+ result["score"] = @score if !options[:compact] || has_score?
9990
+
9991
+ result
9992
+ end
9993
+
9994
+ def to_json(as_json_options = {})
9995
+ require "json"
9996
+ JSON.dump(as_json(as_json_options))
9997
+ end
9386
9998
  end
9387
9999
  class DebugEndGame
9388
10000
  def self.decode(buff)
@@ -9398,23 +10010,15 @@ module Api
9398
10010
  DECLARE_VICTORY = 2
9399
10011
 
9400
10012
  def self.lookup(val)
9401
- if val == 0
9402
- :ENUM_END_RESULT_UNSET
9403
- elsif val == 1
9404
- :SURRENDER
9405
- elsif val == 2
9406
- :DECLARE_VICTORY
9407
- end
10013
+ return :ENUM_END_RESULT_UNSET if val == 0
10014
+ return :SURRENDER if val == 1
10015
+ return :DECLARE_VICTORY if val == 2
9408
10016
  end
9409
10017
 
9410
10018
  def self.resolve(val)
9411
- if val == :ENUM_END_RESULT_UNSET
9412
- 0
9413
- elsif val == :SURRENDER
9414
- 1
9415
- elsif val == :DECLARE_VICTORY
9416
- 2
9417
- end
10019
+ return 0 if val == :ENUM_END_RESULT_UNSET
10020
+ return 1 if val == :SURRENDER
10021
+ return 2 if val == :DECLARE_VICTORY
9418
10022
  end
9419
10023
  end
9420
10024
  # required field readers
@@ -9426,9 +10030,12 @@ module Api
9426
10030
  # enum writers
9427
10031
  def end_result=(v)
9428
10032
  @end_result = Api::DebugEndGame::EndResult.resolve(v) || v
10033
+ @_bitmask |= 0x0000000000000001
9429
10034
  end
9430
10035
 
9431
10036
  def initialize(end_result: nil)
10037
+ @_bitmask = 0
10038
+
9432
10039
  if end_result == nil
9433
10040
  @end_result = 0
9434
10041
  else
@@ -9442,7 +10049,13 @@ module Api
9442
10049
  self.class.encode(self)
9443
10050
  end
9444
10051
 
10052
+ def has_end_result?
10053
+ (@_bitmask & 0x0000000000000001) == 0x0000000000000001
10054
+ end
10055
+
9445
10056
  def decode_from(buff, index, len)
10057
+ @_bitmask = 0
10058
+
9446
10059
  @end_result = 0
9447
10060
 
9448
10061
  return self if index >= len
@@ -9504,20 +10117,39 @@ module Api
9504
10117
  # unexpected, so discard it and continue.
9505
10118
  if !found
9506
10119
  wire_type = tag & 0x7
10120
+
10121
+ unknown_bytes = +"".b
10122
+ val = tag
10123
+ loop do
10124
+ byte = val & 0x7F
10125
+
10126
+ val >>= 7
10127
+ # This drops the top bits,
10128
+ # Otherwise, with a signed right shift,
10129
+ # we get infinity one bits at the top
10130
+ val &= (1 << 57) - 1
10131
+
10132
+ byte |= 0x80 if val != 0
10133
+ unknown_bytes << byte
10134
+ break if val == 0
10135
+ end
10136
+
9507
10137
  case wire_type
9508
10138
  when 0
9509
10139
  i = 0
9510
10140
  while true
9511
10141
  newbyte = buff.getbyte(index)
9512
10142
  index += 1
9513
- break if newbyte.nil? || newbyte < 0x80
10143
+ break if newbyte.nil?
10144
+ unknown_bytes << newbyte
10145
+ break if newbyte < 0x80
9514
10146
  i += 1
9515
10147
  break if i > 9
9516
10148
  end
9517
10149
  when 1
10150
+ unknown_bytes << buff.byteslice(index, 8)
9518
10151
  index += 8
9519
10152
  when 2
9520
- ## PULL_BYTES
9521
10153
  value =
9522
10154
  if (byte0 = buff.getbyte(index)) < 0x80
9523
10155
  index += 1
@@ -9573,15 +10205,30 @@ module Api
9573
10205
  raise "integer decoding error"
9574
10206
  end
9575
10207
 
9576
- buff.byteslice(index, value)
9577
- index += value
10208
+ val = value
10209
+ loop do
10210
+ byte = val & 0x7F
10211
+
10212
+ val >>= 7
10213
+ # This drops the top bits,
10214
+ # Otherwise, with a signed right shift,
10215
+ # we get infinity one bits at the top
10216
+ val &= (1 << 57) - 1
10217
+
10218
+ byte |= 0x80 if val != 0
10219
+ unknown_bytes << byte
10220
+ break if val == 0
10221
+ end
9578
10222
 
9579
- ## END PULL_BYTES
10223
+ unknown_bytes << buff.byteslice(index, value)
10224
+ index += value
9580
10225
  when 5
10226
+ unknown_bytes << buff.byteslice(index, 4)
9581
10227
  index += 4
9582
10228
  else
9583
10229
  raise "unknown wire type #{wire_type}"
9584
10230
  end
10231
+ (@_unknown_fields ||= +"".b) << unknown_bytes
9585
10232
  return self if index >= len
9586
10233
  ## PULL_UINT64
9587
10234
  tag =
@@ -9763,10 +10410,10 @@ module Api
9763
10410
  end
9764
10411
  def _encode(buff)
9765
10412
  val = @end_result
9766
- if val != 0
10413
+ if has_end_result?
9767
10414
  buff << 0x08
9768
10415
 
9769
- while val != 0
10416
+ loop do
9770
10417
  byte = val & 0x7F
9771
10418
 
9772
10419
  val >>= 7
@@ -9777,17 +10424,33 @@ module Api
9777
10424
 
9778
10425
  byte |= 0x80 if val != 0
9779
10426
  buff << byte
10427
+ break if val == 0
9780
10428
  end
9781
10429
  end
9782
-
10430
+ buff << @_unknown_fields if @_unknown_fields
9783
10431
  buff
9784
10432
  end
9785
10433
 
9786
10434
  def to_h
9787
10435
  result = {}
9788
- result["end_result".to_sym] = @end_result
10436
+
10437
+ result[:"end_result"] = @end_result
10438
+
10439
+ result
10440
+ end
10441
+
10442
+ def as_json(options = {})
10443
+ result = {}
10444
+
10445
+ result["endResult"] = @end_result if !options[:compact] || has_end_result?
10446
+
9789
10447
  result
9790
10448
  end
10449
+
10450
+ def to_json(as_json_options = {})
10451
+ require "json"
10452
+ JSON.dump(as_json(as_json_options))
10453
+ end
9791
10454
  end
9792
10455
  class DebugSetUnitValue
9793
10456
  def self.decode(buff)
@@ -9804,27 +10467,17 @@ module Api
9804
10467
  SHIELDS = 3
9805
10468
 
9806
10469
  def self.lookup(val)
9807
- if val == 0
9808
- :ENUM_UNIT_VALUE_UNSET
9809
- elsif val == 1
9810
- :ENERGY
9811
- elsif val == 2
9812
- :LIFE
9813
- elsif val == 3
9814
- :SHIELDS
9815
- end
10470
+ return :ENUM_UNIT_VALUE_UNSET if val == 0
10471
+ return :ENERGY if val == 1
10472
+ return :LIFE if val == 2
10473
+ return :SHIELDS if val == 3
9816
10474
  end
9817
10475
 
9818
10476
  def self.resolve(val)
9819
- if val == :ENUM_UNIT_VALUE_UNSET
9820
- 0
9821
- elsif val == :ENERGY
9822
- 1
9823
- elsif val == :LIFE
9824
- 2
9825
- elsif val == :SHIELDS
9826
- 3
9827
- end
10477
+ return 0 if val == :ENUM_UNIT_VALUE_UNSET
10478
+ return 1 if val == :ENERGY
10479
+ return 2 if val == :LIFE
10480
+ return 3 if val == :SHIELDS
9828
10481
  end
9829
10482
  end
9830
10483
  # required field readers
@@ -9842,6 +10495,7 @@ module Api
9842
10495
  # enum writers
9843
10496
  def unit_value=(v)
9844
10497
  @unit_value = Api::DebugSetUnitValue::UnitValue.resolve(v) || v
10498
+ @_bitmask |= 0x0000000000000001
9845
10499
  end
9846
10500
 
9847
10501
  # BEGIN writers for optional fields
@@ -9896,6 +10550,10 @@ module Api
9896
10550
  self.class.encode(self)
9897
10551
  end
9898
10552
 
10553
+ def has_unit_value?
10554
+ (@_bitmask & 0x0000000000000001) == 0x0000000000000001
10555
+ end
10556
+
9899
10557
  def has_value?
9900
10558
  (@_bitmask & 0x0000000000000002) == 0x0000000000000002
9901
10559
  end
@@ -9970,20 +10628,39 @@ module Api
9970
10628
  # unexpected, so discard it and continue.
9971
10629
  if !found
9972
10630
  wire_type = tag & 0x7
10631
+
10632
+ unknown_bytes = +"".b
10633
+ val = tag
10634
+ loop do
10635
+ byte = val & 0x7F
10636
+
10637
+ val >>= 7
10638
+ # This drops the top bits,
10639
+ # Otherwise, with a signed right shift,
10640
+ # we get infinity one bits at the top
10641
+ val &= (1 << 57) - 1
10642
+
10643
+ byte |= 0x80 if val != 0
10644
+ unknown_bytes << byte
10645
+ break if val == 0
10646
+ end
10647
+
9973
10648
  case wire_type
9974
10649
  when 0
9975
10650
  i = 0
9976
10651
  while true
9977
10652
  newbyte = buff.getbyte(index)
9978
10653
  index += 1
9979
- break if newbyte.nil? || newbyte < 0x80
10654
+ break if newbyte.nil?
10655
+ unknown_bytes << newbyte
10656
+ break if newbyte < 0x80
9980
10657
  i += 1
9981
10658
  break if i > 9
9982
10659
  end
9983
10660
  when 1
10661
+ unknown_bytes << buff.byteslice(index, 8)
9984
10662
  index += 8
9985
10663
  when 2
9986
- ## PULL_BYTES
9987
10664
  value =
9988
10665
  if (byte0 = buff.getbyte(index)) < 0x80
9989
10666
  index += 1
@@ -10039,15 +10716,30 @@ module Api
10039
10716
  raise "integer decoding error"
10040
10717
  end
10041
10718
 
10042
- buff.byteslice(index, value)
10043
- index += value
10719
+ val = value
10720
+ loop do
10721
+ byte = val & 0x7F
10722
+
10723
+ val >>= 7
10724
+ # This drops the top bits,
10725
+ # Otherwise, with a signed right shift,
10726
+ # we get infinity one bits at the top
10727
+ val &= (1 << 57) - 1
10728
+
10729
+ byte |= 0x80 if val != 0
10730
+ unknown_bytes << byte
10731
+ break if val == 0
10732
+ end
10044
10733
 
10045
- ## END PULL_BYTES
10734
+ unknown_bytes << buff.byteslice(index, value)
10735
+ index += value
10046
10736
  when 5
10737
+ unknown_bytes << buff.byteslice(index, 4)
10047
10738
  index += 4
10048
10739
  else
10049
10740
  raise "unknown wire type #{wire_type}"
10050
10741
  end
10742
+ (@_unknown_fields ||= +"".b) << unknown_bytes
10051
10743
  return self if index >= len
10052
10744
  ## PULL_UINT64
10053
10745
  tag =
@@ -10395,10 +11087,10 @@ module Api
10395
11087
  end
10396
11088
  def _encode(buff)
10397
11089
  val = @unit_value
10398
- if val != 0
11090
+ if has_unit_value?
10399
11091
  buff << 0x08
10400
11092
 
10401
- while val != 0
11093
+ loop do
10402
11094
  byte = val & 0x7F
10403
11095
 
10404
11096
  val >>= 7
@@ -10409,37 +11101,56 @@ module Api
10409
11101
 
10410
11102
  byte |= 0x80 if val != 0
10411
11103
  buff << byte
11104
+ break if val == 0
10412
11105
  end
10413
11106
  end
10414
11107
 
10415
11108
  val = @value
10416
- if val != 0
11109
+ if has_value?
10417
11110
  buff << 0x15
10418
11111
 
10419
11112
  [val].pack("e", buffer: buff)
10420
11113
  end
10421
11114
 
10422
11115
  val = @unit_tag
10423
- if val != 0
11116
+ if has_unit_tag?
10424
11117
  buff << 0x18
10425
11118
 
10426
- while val != 0
11119
+ loop do
10427
11120
  byte = val & 0x7F
10428
11121
  val >>= 7
10429
11122
  byte |= 0x80 if val > 0
10430
11123
  buff << byte
11124
+ break if val == 0
10431
11125
  end
10432
11126
  end
10433
-
11127
+ buff << @_unknown_fields if @_unknown_fields
10434
11128
  buff
10435
11129
  end
10436
11130
 
10437
11131
  def to_h
10438
11132
  result = {}
10439
- result["unit_value".to_sym] = @unit_value
10440
- result["value".to_sym] = @value
10441
- result["unit_tag".to_sym] = @unit_tag
11133
+
11134
+ result[:"unit_value"] = @unit_value
11135
+ result[:"value"] = @value
11136
+ result[:"unit_tag"] = @unit_tag
11137
+
11138
+ result
11139
+ end
11140
+
11141
+ def as_json(options = {})
11142
+ result = {}
11143
+
11144
+ result["unitValue"] = @unit_value if !options[:compact] || has_unit_value?
11145
+ result["value"] = @value if !options[:compact] || has_value?
11146
+ result["unitTag"] = @unit_tag if !options[:compact] || has_unit_tag?
11147
+
10442
11148
  result
10443
11149
  end
11150
+
11151
+ def to_json(as_json_options = {})
11152
+ require "json"
11153
+ JSON.dump(as_json(as_json_options))
11154
+ end
10444
11155
  end
10445
11156
  end