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