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.
- checksums.yaml +4 -4
- data/data/sc2ai/protocol/data.proto +2 -2
- data/data/sc2ai/protocol/debug.proto +1 -1
- data/data/sc2ai/protocol/raw.proto +6 -6
- data/data/sc2ai/protocol/sc2api.proto +1 -1
- data/data/sc2ai/protocol/ui.proto +1 -1
- data/{lib/docker_build → docker_build}/Dockerfile.ruby +2 -2
- data/lib/sc2ai/cli/ladderzip.rb +1 -1
- data/lib/sc2ai/local_play/client.rb +1 -1
- data/lib/sc2ai/local_play/match.rb +1 -0
- data/lib/sc2ai/overrides/async/process/child.rb +2 -1
- data/lib/sc2ai/paths.rb +0 -1
- data/lib/sc2ai/player/debug.rb +3 -3
- data/lib/sc2ai/player.rb +9 -0
- data/lib/sc2ai/protocol/common_pb.rb +460 -105
- data/lib/sc2ai/protocol/data_pb.rb +833 -482
- data/lib/sc2ai/protocol/debug_pb.rb +1112 -401
- data/lib/sc2ai/protocol/error_pb.rb +430 -862
- data/lib/sc2ai/protocol/extensions/action.rb +1 -1
- data/lib/sc2ai/protocol/extensions/color.rb +1 -1
- data/lib/sc2ai/protocol/extensions/point.rb +1 -1
- data/lib/sc2ai/protocol/extensions/point_2_d.rb +1 -1
- data/lib/sc2ai/protocol/extensions/point_distance.rb +4 -4
- data/lib/sc2ai/protocol/extensions/position.rb +20 -0
- data/lib/sc2ai/protocol/extensions/power_source.rb +1 -1
- data/lib/sc2ai/protocol/extensions/unit.rb +1 -1
- data/lib/sc2ai/protocol/extensions/unit_type_data.rb +1 -1
- data/lib/sc2ai/protocol/query_pb.rb +558 -88
- data/lib/sc2ai/protocol/raw_pb.rb +1829 -1156
- data/lib/sc2ai/protocol/sc2api_pb.rb +5233 -1463
- data/lib/sc2ai/protocol/score_pb.rb +444 -103
- data/lib/sc2ai/protocol/spatial_pb.rb +935 -145
- data/lib/sc2ai/protocol/ui_pb.rb +1432 -435
- data/lib/sc2ai/version.rb +1 -1
- data/lib/templates/new/api/data.proto +2 -2
- data/lib/templates/new/api/debug.proto +1 -1
- data/lib/templates/new/api/raw.proto +6 -6
- data/lib/templates/new/api/sc2api.proto +1 -1
- data/lib/templates/new/api/ui.proto +1 -1
- data/lib/templates/new/run_example_match.rb.tt +1 -1
- data/sig/sc2ai.rbs +1361 -23
- metadata +7 -7
- /data/{lib/docker_build → docker_build}/docker-compose-base-image.yml +0 -0
- /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
|
-
|
24
|
-
|
25
|
-
|
26
|
-
|
27
|
-
|
28
|
-
|
29
|
-
|
30
|
-
|
31
|
-
|
32
|
-
|
33
|
-
|
34
|
-
|
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
|
-
|
54
|
-
|
55
|
-
|
56
|
-
|
57
|
-
|
58
|
-
|
59
|
-
|
60
|
-
|
61
|
-
|
62
|
-
|
63
|
-
|
64
|
-
|
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?
|
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
|
-
|
366
|
-
|
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
|
-
|
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
|
-
|
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
|
-
|
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?
|
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
|
-
|
1915
|
-
|
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
|
-
|
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
|
-
|
2745
|
-
result["
|
2746
|
-
result["
|
2747
|
-
result["
|
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?
|
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
|
-
|
2945
|
-
|
3111
|
+
val = value
|
3112
|
+
loop do
|
3113
|
+
byte = val & 0x7F
|
2946
3114
|
|
2947
|
-
|
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
|
-
|
3339
|
-
result["
|
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?
|
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
|
-
|
3583
|
-
|
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
|
-
|
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
|
4212
|
+
if has_r?
|
3977
4213
|
buff << 0x08
|
3978
4214
|
|
3979
|
-
|
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
|
4225
|
+
if has_g?
|
3989
4226
|
buff << 0x10
|
3990
4227
|
|
3991
|
-
|
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
|
4238
|
+
if has_b?
|
4001
4239
|
buff << 0x18
|
4002
4240
|
|
4003
|
-
|
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
|
-
|
4017
|
-
result["
|
4018
|
-
result["
|
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?
|
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
|
-
|
4288
|
-
|
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
|
-
|
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 (
|
5253
|
+
if (len = val.bytesize) > 0 || has_text?
|
4964
5254
|
buff << 0x12
|
4965
|
-
|
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
|
5363
|
+
if has_size?
|
5073
5364
|
buff << 0x28
|
5074
5365
|
|
5075
|
-
|
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
|
-
|
5089
|
-
result["
|
5090
|
-
result["
|
5091
|
-
result["
|
5092
|
-
result["
|
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?
|
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
|
-
|
5290
|
-
|
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
|
-
|
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
|
-
|
5685
|
-
result["
|
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?
|
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
|
-
|
5902
|
-
|
6299
|
+
val = value
|
6300
|
+
loop do
|
6301
|
+
byte = val & 0x7F
|
5903
6302
|
|
5904
|
-
|
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
|
-
|
6457
|
-
result["
|
6458
|
-
result["
|
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?
|
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
|
-
|
6675
|
-
|
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
|
-
|
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
|
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
|
-
|
7135
|
-
result["
|
7136
|
-
result["
|
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?
|
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
|
-
|
7399
|
-
|
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
|
-
|
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
|
8441
|
+
if has_unit_type?
|
7918
8442
|
buff << 0x08
|
7919
8443
|
|
7920
|
-
|
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
|
8454
|
+
if has_owner?
|
7930
8455
|
buff << 0x10
|
7931
8456
|
|
7932
|
-
|
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
|
8521
|
+
if has_quantity?
|
7996
8522
|
buff << 0x20
|
7997
8523
|
|
7998
|
-
|
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
|
-
|
8012
|
-
result["
|
8013
|
-
result["
|
8014
|
-
result["
|
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?
|
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
|
-
|
8187
|
-
|
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
|
-
|
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 ==
|
8831
|
+
if tag == 0x8
|
8251
8832
|
found = true
|
8252
|
-
##
|
8253
|
-
|
8254
|
-
|
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
|
-
|
8885
|
+
## END PULL_UINT64
|
8303
8886
|
|
8304
|
-
|
8305
|
-
list = @tag
|
8306
|
-
while true
|
8307
|
-
break if index >= goal
|
8887
|
+
return self if index >= len
|
8308
8888
|
## PULL_UINT64
|
8309
|
-
|
8310
|
-
index
|
8311
|
-
|
8312
|
-
|
8313
|
-
index
|
8314
|
-
|
8315
|
-
|
8316
|
-
index
|
8317
|
-
|
8318
|
-
|
8319
|
-
index
|
8320
|
-
|
8321
|
-
(
|
8322
|
-
|
8323
|
-
index
|
8324
|
-
|
8325
|
-
(
|
8326
|
-
|
8327
|
-
|
8328
|
-
(byte5
|
8329
|
-
|
8330
|
-
|
8331
|
-
|
8332
|
-
|
8333
|
-
|
8334
|
-
|
8335
|
-
|
8336
|
-
|
8337
|
-
|
8338
|
-
|
8339
|
-
|
8340
|
-
|
8341
|
-
|
8342
|
-
|
8343
|
-
|
8344
|
-
|
8345
|
-
|
8346
|
-
|
8347
|
-
|
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
|
-
|
8350
|
-
|
8351
|
-
|
8352
|
-
|
8353
|
-
|
8354
|
-
|
8355
|
-
|
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
|
-
|
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
|
-
|
8442
|
-
|
8978
|
+
def to_h
|
8979
|
+
result = {}
|
8443
8980
|
|
8444
|
-
|
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
|
-
|
8451
|
-
|
8452
|
-
current_len += 1
|
8983
|
+
result
|
8984
|
+
end
|
8453
8985
|
|
8454
|
-
|
8455
|
-
|
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
|
-
|
8463
|
-
buff.bytesplice(current_len, 0, "*********", 0, encoded_int_len)
|
8989
|
+
tmp_tag = @tag
|
8464
8990
|
|
8465
|
-
|
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
|
-
|
8993
|
+
result
|
8477
8994
|
end
|
8478
8995
|
|
8479
|
-
def
|
8480
|
-
|
8481
|
-
|
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
|
-
|
8502
|
-
|
8503
|
-
|
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
|
-
|
8514
|
-
|
8515
|
-
|
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?
|
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
|
-
|
8716
|
-
|
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
|
-
|
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
|
9570
|
+
if has_test?
|
9026
9571
|
buff << 0x08
|
9027
9572
|
|
9028
|
-
|
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
|
9589
|
+
if has_delay_ms?
|
9044
9590
|
buff << 0x10
|
9045
9591
|
|
9046
|
-
|
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
|
-
|
9066
|
-
result["
|
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?
|
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
|
-
|
9245
|
-
|
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
|
-
|
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
|
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
|
-
|
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
|
-
|
9403
|
-
|
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
|
-
|
9413
|
-
|
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?
|
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
|
-
|
9577
|
-
|
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
|
-
|
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
|
10413
|
+
if has_end_result?
|
9767
10414
|
buff << 0x08
|
9768
10415
|
|
9769
|
-
|
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
|
-
|
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
|
-
|
9809
|
-
|
9810
|
-
|
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
|
-
|
9821
|
-
|
9822
|
-
|
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?
|
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
|
-
|
10043
|
-
|
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
|
-
|
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
|
11090
|
+
if has_unit_value?
|
10399
11091
|
buff << 0x08
|
10400
11092
|
|
10401
|
-
|
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
|
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
|
11116
|
+
if has_unit_tag?
|
10424
11117
|
buff << 0x18
|
10425
11118
|
|
10426
|
-
|
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
|
-
|
10440
|
-
result["
|
10441
|
-
result["
|
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
|