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
@@ -11,31 +11,19 @@ module Api
|
|
11
11
|
PLACEHOLDER = 4
|
12
12
|
|
13
13
|
def self.lookup(val)
|
14
|
-
if val == 0
|
15
|
-
|
16
|
-
|
17
|
-
|
18
|
-
|
19
|
-
:SNAPSHOT
|
20
|
-
elsif val == 3
|
21
|
-
:HIDDEN
|
22
|
-
elsif val == 4
|
23
|
-
:PLACEHOLDER
|
24
|
-
end
|
14
|
+
return :ENUM_DISPLAY_TYPE_UNSET if val == 0
|
15
|
+
return :VISIBLE if val == 1
|
16
|
+
return :SNAPSHOT if val == 2
|
17
|
+
return :HIDDEN if val == 3
|
18
|
+
return :PLACEHOLDER if val == 4
|
25
19
|
end
|
26
20
|
|
27
21
|
def self.resolve(val)
|
28
|
-
if val == :ENUM_DISPLAY_TYPE_UNSET
|
29
|
-
|
30
|
-
|
31
|
-
|
32
|
-
|
33
|
-
2
|
34
|
-
elsif val == :HIDDEN
|
35
|
-
3
|
36
|
-
elsif val == :PLACEHOLDER
|
37
|
-
4
|
38
|
-
end
|
22
|
+
return 0 if val == :ENUM_DISPLAY_TYPE_UNSET
|
23
|
+
return 1 if val == :VISIBLE
|
24
|
+
return 2 if val == :SNAPSHOT
|
25
|
+
return 3 if val == :HIDDEN
|
26
|
+
return 4 if val == :PLACEHOLDER
|
39
27
|
end
|
40
28
|
end
|
41
29
|
module Alliance
|
@@ -46,31 +34,19 @@ module Api
|
|
46
34
|
ENEMY = 4
|
47
35
|
|
48
36
|
def self.lookup(val)
|
49
|
-
if val == 0
|
50
|
-
|
51
|
-
|
52
|
-
|
53
|
-
|
54
|
-
:ALLY
|
55
|
-
elsif val == 3
|
56
|
-
:NEUTRAL
|
57
|
-
elsif val == 4
|
58
|
-
:ENEMY
|
59
|
-
end
|
37
|
+
return :ENUM_ALLIANCE_UNSET if val == 0
|
38
|
+
return :SELF if val == 1
|
39
|
+
return :ALLY if val == 2
|
40
|
+
return :NEUTRAL if val == 3
|
41
|
+
return :ENEMY if val == 4
|
60
42
|
end
|
61
43
|
|
62
44
|
def self.resolve(val)
|
63
|
-
if val == :ENUM_ALLIANCE_UNSET
|
64
|
-
|
65
|
-
|
66
|
-
|
67
|
-
|
68
|
-
2
|
69
|
-
elsif val == :NEUTRAL
|
70
|
-
3
|
71
|
-
elsif val == :ENEMY
|
72
|
-
4
|
73
|
-
end
|
45
|
+
return 0 if val == :ENUM_ALLIANCE_UNSET
|
46
|
+
return 1 if val == :SELF
|
47
|
+
return 2 if val == :ALLY
|
48
|
+
return 3 if val == :NEUTRAL
|
49
|
+
return 4 if val == :ENEMY
|
74
50
|
end
|
75
51
|
end
|
76
52
|
module CloakState
|
@@ -81,31 +57,19 @@ module Api
|
|
81
57
|
CLOAKED_ALLIED = 4
|
82
58
|
|
83
59
|
def self.lookup(val)
|
84
|
-
if val == 0
|
85
|
-
|
86
|
-
|
87
|
-
|
88
|
-
|
89
|
-
:CLOAKED_DETECTED
|
90
|
-
elsif val == 3
|
91
|
-
:NOT_CLOAKED
|
92
|
-
elsif val == 4
|
93
|
-
:CLOAKED_ALLIED
|
94
|
-
end
|
60
|
+
return :CLOAKED_UNKNOWN if val == 0
|
61
|
+
return :CLOAKED if val == 1
|
62
|
+
return :CLOAKED_DETECTED if val == 2
|
63
|
+
return :NOT_CLOAKED if val == 3
|
64
|
+
return :CLOAKED_ALLIED if val == 4
|
95
65
|
end
|
96
66
|
|
97
67
|
def self.resolve(val)
|
98
|
-
if val == :CLOAKED_UNKNOWN
|
99
|
-
|
100
|
-
|
101
|
-
|
102
|
-
|
103
|
-
2
|
104
|
-
elsif val == :NOT_CLOAKED
|
105
|
-
3
|
106
|
-
elsif val == :CLOAKED_ALLIED
|
107
|
-
4
|
108
|
-
end
|
68
|
+
return 0 if val == :CLOAKED_UNKNOWN
|
69
|
+
return 1 if val == :CLOAKED
|
70
|
+
return 2 if val == :CLOAKED_DETECTED
|
71
|
+
return 3 if val == :NOT_CLOAKED
|
72
|
+
return 4 if val == :CLOAKED_ALLIED
|
109
73
|
end
|
110
74
|
end
|
111
75
|
|
@@ -306,20 +270,39 @@ module Api
|
|
306
270
|
# unexpected, so discard it and continue.
|
307
271
|
if !found
|
308
272
|
wire_type = tag & 0x7
|
273
|
+
|
274
|
+
unknown_bytes = +"".b
|
275
|
+
val = tag
|
276
|
+
loop do
|
277
|
+
byte = val & 0x7F
|
278
|
+
|
279
|
+
val >>= 7
|
280
|
+
# This drops the top bits,
|
281
|
+
# Otherwise, with a signed right shift,
|
282
|
+
# we get infinity one bits at the top
|
283
|
+
val &= (1 << 57) - 1
|
284
|
+
|
285
|
+
byte |= 0x80 if val != 0
|
286
|
+
unknown_bytes << byte
|
287
|
+
break if val == 0
|
288
|
+
end
|
289
|
+
|
309
290
|
case wire_type
|
310
291
|
when 0
|
311
292
|
i = 0
|
312
293
|
while true
|
313
294
|
newbyte = buff.getbyte(index)
|
314
295
|
index += 1
|
315
|
-
break if newbyte.nil?
|
296
|
+
break if newbyte.nil?
|
297
|
+
unknown_bytes << newbyte
|
298
|
+
break if newbyte < 0x80
|
316
299
|
i += 1
|
317
300
|
break if i > 9
|
318
301
|
end
|
319
302
|
when 1
|
303
|
+
unknown_bytes << buff.byteslice(index, 8)
|
320
304
|
index += 8
|
321
305
|
when 2
|
322
|
-
## PULL_BYTES
|
323
306
|
value =
|
324
307
|
if (byte0 = buff.getbyte(index)) < 0x80
|
325
308
|
index += 1
|
@@ -375,15 +358,30 @@ module Api
|
|
375
358
|
raise "integer decoding error"
|
376
359
|
end
|
377
360
|
|
378
|
-
|
379
|
-
|
361
|
+
val = value
|
362
|
+
loop do
|
363
|
+
byte = val & 0x7F
|
364
|
+
|
365
|
+
val >>= 7
|
366
|
+
# This drops the top bits,
|
367
|
+
# Otherwise, with a signed right shift,
|
368
|
+
# we get infinity one bits at the top
|
369
|
+
val &= (1 << 57) - 1
|
370
|
+
|
371
|
+
byte |= 0x80 if val != 0
|
372
|
+
unknown_bytes << byte
|
373
|
+
break if val == 0
|
374
|
+
end
|
380
375
|
|
381
|
-
|
376
|
+
unknown_bytes << buff.byteslice(index, value)
|
377
|
+
index += value
|
382
378
|
when 5
|
379
|
+
unknown_bytes << buff.byteslice(index, 4)
|
383
380
|
index += 4
|
384
381
|
else
|
385
382
|
raise "unknown wire type #{wire_type}"
|
386
383
|
end
|
384
|
+
(@_unknown_fields ||= +"".b) << unknown_bytes
|
387
385
|
return self if index >= len
|
388
386
|
## PULL_UINT64
|
389
387
|
tag =
|
@@ -1437,20 +1435,73 @@ module Api
|
|
1437
1435
|
end
|
1438
1436
|
end
|
1439
1437
|
end
|
1440
|
-
|
1438
|
+
buff << @_unknown_fields if @_unknown_fields
|
1441
1439
|
buff
|
1442
1440
|
end
|
1443
1441
|
|
1444
1442
|
def to_h
|
1445
1443
|
result = {}
|
1446
|
-
|
1447
|
-
result["
|
1448
|
-
result["
|
1449
|
-
result["
|
1450
|
-
result["
|
1451
|
-
result["
|
1444
|
+
|
1445
|
+
result[:"map_size"] = @map_size.to_h
|
1446
|
+
result[:"pathing_grid"] = @pathing_grid.to_h
|
1447
|
+
result[:"terrain_height"] = @terrain_height.to_h
|
1448
|
+
result[:"placement_grid"] = @placement_grid.to_h
|
1449
|
+
result[:"playable_area"] = @playable_area.to_h
|
1450
|
+
result[:"start_locations"] = @start_locations.map(&:to_h)
|
1451
|
+
|
1452
|
+
result
|
1453
|
+
end
|
1454
|
+
|
1455
|
+
def as_json(options = {})
|
1456
|
+
result = {}
|
1457
|
+
|
1458
|
+
result["mapSize"] = (
|
1459
|
+
if @map_size.nil?
|
1460
|
+
{}
|
1461
|
+
else
|
1462
|
+
@map_size.as_json(options)
|
1463
|
+
end
|
1464
|
+
) if !options[:compact] || has_map_size?
|
1465
|
+
result["pathingGrid"] = (
|
1466
|
+
if @pathing_grid.nil?
|
1467
|
+
{}
|
1468
|
+
else
|
1469
|
+
@pathing_grid.as_json(options)
|
1470
|
+
end
|
1471
|
+
) if !options[:compact] || has_pathing_grid?
|
1472
|
+
result["terrainHeight"] = (
|
1473
|
+
if @terrain_height.nil?
|
1474
|
+
{}
|
1475
|
+
else
|
1476
|
+
@terrain_height.as_json(options)
|
1477
|
+
end
|
1478
|
+
) if !options[:compact] || has_terrain_height?
|
1479
|
+
result["placementGrid"] = (
|
1480
|
+
if @placement_grid.nil?
|
1481
|
+
{}
|
1482
|
+
else
|
1483
|
+
@placement_grid.as_json(options)
|
1484
|
+
end
|
1485
|
+
) if !options[:compact] || has_placement_grid?
|
1486
|
+
result["playableArea"] = (
|
1487
|
+
if @playable_area.nil?
|
1488
|
+
{}
|
1489
|
+
else
|
1490
|
+
@playable_area.as_json(options)
|
1491
|
+
end
|
1492
|
+
) if !options[:compact] || has_playable_area?
|
1493
|
+
tmp_start_locations = @start_locations.map { |v| v.as_json(options) }
|
1494
|
+
|
1495
|
+
result["startLocations"] = tmp_start_locations if !options[:compact] ||
|
1496
|
+
tmp_start_locations.any?
|
1497
|
+
|
1452
1498
|
result
|
1453
1499
|
end
|
1500
|
+
|
1501
|
+
def to_json(as_json_options = {})
|
1502
|
+
require "json"
|
1503
|
+
JSON.dump(as_json(as_json_options))
|
1504
|
+
end
|
1454
1505
|
end
|
1455
1506
|
class ObservationRaw
|
1456
1507
|
def self.decode(buff)
|
@@ -1629,20 +1680,39 @@ module Api
|
|
1629
1680
|
# unexpected, so discard it and continue.
|
1630
1681
|
if !found
|
1631
1682
|
wire_type = tag & 0x7
|
1683
|
+
|
1684
|
+
unknown_bytes = +"".b
|
1685
|
+
val = tag
|
1686
|
+
loop do
|
1687
|
+
byte = val & 0x7F
|
1688
|
+
|
1689
|
+
val >>= 7
|
1690
|
+
# This drops the top bits,
|
1691
|
+
# Otherwise, with a signed right shift,
|
1692
|
+
# we get infinity one bits at the top
|
1693
|
+
val &= (1 << 57) - 1
|
1694
|
+
|
1695
|
+
byte |= 0x80 if val != 0
|
1696
|
+
unknown_bytes << byte
|
1697
|
+
break if val == 0
|
1698
|
+
end
|
1699
|
+
|
1632
1700
|
case wire_type
|
1633
1701
|
when 0
|
1634
1702
|
i = 0
|
1635
1703
|
while true
|
1636
1704
|
newbyte = buff.getbyte(index)
|
1637
1705
|
index += 1
|
1638
|
-
break if newbyte.nil?
|
1706
|
+
break if newbyte.nil?
|
1707
|
+
unknown_bytes << newbyte
|
1708
|
+
break if newbyte < 0x80
|
1639
1709
|
i += 1
|
1640
1710
|
break if i > 9
|
1641
1711
|
end
|
1642
1712
|
when 1
|
1713
|
+
unknown_bytes << buff.byteslice(index, 8)
|
1643
1714
|
index += 8
|
1644
1715
|
when 2
|
1645
|
-
## PULL_BYTES
|
1646
1716
|
value =
|
1647
1717
|
if (byte0 = buff.getbyte(index)) < 0x80
|
1648
1718
|
index += 1
|
@@ -1698,15 +1768,30 @@ module Api
|
|
1698
1768
|
raise "integer decoding error"
|
1699
1769
|
end
|
1700
1770
|
|
1701
|
-
|
1702
|
-
|
1771
|
+
val = value
|
1772
|
+
loop do
|
1773
|
+
byte = val & 0x7F
|
1774
|
+
|
1775
|
+
val >>= 7
|
1776
|
+
# This drops the top bits,
|
1777
|
+
# Otherwise, with a signed right shift,
|
1778
|
+
# we get infinity one bits at the top
|
1779
|
+
val &= (1 << 57) - 1
|
1780
|
+
|
1781
|
+
byte |= 0x80 if val != 0
|
1782
|
+
unknown_bytes << byte
|
1783
|
+
break if val == 0
|
1784
|
+
end
|
1703
1785
|
|
1704
|
-
|
1786
|
+
unknown_bytes << buff.byteslice(index, value)
|
1787
|
+
index += value
|
1705
1788
|
when 5
|
1789
|
+
unknown_bytes << buff.byteslice(index, 4)
|
1706
1790
|
index += 4
|
1707
1791
|
else
|
1708
1792
|
raise "unknown wire type #{wire_type}"
|
1709
1793
|
end
|
1794
|
+
(@_unknown_fields ||= +"".b) << unknown_bytes
|
1710
1795
|
return self if index >= len
|
1711
1796
|
## PULL_UINT64
|
1712
1797
|
tag =
|
@@ -2816,20 +2901,62 @@ module Api
|
|
2816
2901
|
end
|
2817
2902
|
end
|
2818
2903
|
end
|
2819
|
-
|
2904
|
+
buff << @_unknown_fields if @_unknown_fields
|
2820
2905
|
buff
|
2821
2906
|
end
|
2822
2907
|
|
2823
2908
|
def to_h
|
2824
2909
|
result = {}
|
2825
|
-
|
2826
|
-
result["
|
2827
|
-
result["
|
2828
|
-
result["
|
2829
|
-
result["
|
2830
|
-
result["
|
2910
|
+
|
2911
|
+
result[:"player"] = @player.to_h
|
2912
|
+
result[:"units"] = @units.map(&:to_h)
|
2913
|
+
result[:"map_state"] = @map_state.to_h
|
2914
|
+
result[:"event"] = @event.to_h
|
2915
|
+
result[:"effects"] = @effects.map(&:to_h)
|
2916
|
+
result[:"radar"] = @radar.map(&:to_h)
|
2917
|
+
|
2918
|
+
result
|
2919
|
+
end
|
2920
|
+
|
2921
|
+
def as_json(options = {})
|
2922
|
+
result = {}
|
2923
|
+
|
2924
|
+
result["player"] = (
|
2925
|
+
if @player.nil?
|
2926
|
+
{}
|
2927
|
+
else
|
2928
|
+
@player.as_json(options)
|
2929
|
+
end
|
2930
|
+
) if !options[:compact] || has_player?
|
2931
|
+
tmp_units = @units.map { |v| v.as_json(options) }
|
2932
|
+
|
2933
|
+
result["units"] = tmp_units if !options[:compact] || tmp_units.any?
|
2934
|
+
|
2935
|
+
result["mapState"] = (
|
2936
|
+
if @map_state.nil?
|
2937
|
+
{}
|
2938
|
+
else
|
2939
|
+
@map_state.as_json(options)
|
2940
|
+
end
|
2941
|
+
) if !options[:compact] || has_map_state?
|
2942
|
+
result["event"] = @event.nil? ? {} : @event.as_json(options) if !options[
|
2943
|
+
:compact
|
2944
|
+
] || has_event?
|
2945
|
+
tmp_effects = @effects.map { |v| v.as_json(options) }
|
2946
|
+
|
2947
|
+
result["effects"] = tmp_effects if !options[:compact] || tmp_effects.any?
|
2948
|
+
|
2949
|
+
tmp_radar = @radar.map { |v| v.as_json(options) }
|
2950
|
+
|
2951
|
+
result["radar"] = tmp_radar if !options[:compact] || tmp_radar.any?
|
2952
|
+
|
2831
2953
|
result
|
2832
2954
|
end
|
2955
|
+
|
2956
|
+
def to_json(as_json_options = {})
|
2957
|
+
require "json"
|
2958
|
+
JSON.dump(as_json(as_json_options))
|
2959
|
+
end
|
2833
2960
|
end
|
2834
2961
|
class RadarRing
|
2835
2962
|
def self.decode(buff)
|
@@ -2955,20 +3082,39 @@ module Api
|
|
2955
3082
|
# unexpected, so discard it and continue.
|
2956
3083
|
if !found
|
2957
3084
|
wire_type = tag & 0x7
|
3085
|
+
|
3086
|
+
unknown_bytes = +"".b
|
3087
|
+
val = tag
|
3088
|
+
loop do
|
3089
|
+
byte = val & 0x7F
|
3090
|
+
|
3091
|
+
val >>= 7
|
3092
|
+
# This drops the top bits,
|
3093
|
+
# Otherwise, with a signed right shift,
|
3094
|
+
# we get infinity one bits at the top
|
3095
|
+
val &= (1 << 57) - 1
|
3096
|
+
|
3097
|
+
byte |= 0x80 if val != 0
|
3098
|
+
unknown_bytes << byte
|
3099
|
+
break if val == 0
|
3100
|
+
end
|
3101
|
+
|
2958
3102
|
case wire_type
|
2959
3103
|
when 0
|
2960
3104
|
i = 0
|
2961
3105
|
while true
|
2962
3106
|
newbyte = buff.getbyte(index)
|
2963
3107
|
index += 1
|
2964
|
-
break if newbyte.nil?
|
3108
|
+
break if newbyte.nil?
|
3109
|
+
unknown_bytes << newbyte
|
3110
|
+
break if newbyte < 0x80
|
2965
3111
|
i += 1
|
2966
3112
|
break if i > 9
|
2967
3113
|
end
|
2968
3114
|
when 1
|
3115
|
+
unknown_bytes << buff.byteslice(index, 8)
|
2969
3116
|
index += 8
|
2970
3117
|
when 2
|
2971
|
-
## PULL_BYTES
|
2972
3118
|
value =
|
2973
3119
|
if (byte0 = buff.getbyte(index)) < 0x80
|
2974
3120
|
index += 1
|
@@ -3024,15 +3170,30 @@ module Api
|
|
3024
3170
|
raise "integer decoding error"
|
3025
3171
|
end
|
3026
3172
|
|
3027
|
-
|
3028
|
-
|
3173
|
+
val = value
|
3174
|
+
loop do
|
3175
|
+
byte = val & 0x7F
|
3176
|
+
|
3177
|
+
val >>= 7
|
3178
|
+
# This drops the top bits,
|
3179
|
+
# Otherwise, with a signed right shift,
|
3180
|
+
# we get infinity one bits at the top
|
3181
|
+
val &= (1 << 57) - 1
|
3182
|
+
|
3183
|
+
byte |= 0x80 if val != 0
|
3184
|
+
unknown_bytes << byte
|
3185
|
+
break if val == 0
|
3186
|
+
end
|
3029
3187
|
|
3030
|
-
|
3188
|
+
unknown_bytes << buff.byteslice(index, value)
|
3189
|
+
index += value
|
3031
3190
|
when 5
|
3191
|
+
unknown_bytes << buff.byteslice(index, 4)
|
3032
3192
|
index += 4
|
3033
3193
|
else
|
3034
3194
|
raise "unknown wire type #{wire_type}"
|
3035
3195
|
end
|
3196
|
+
(@_unknown_fields ||= +"".b) << unknown_bytes
|
3036
3197
|
return self if index >= len
|
3037
3198
|
## PULL_UINT64
|
3038
3199
|
tag =
|
@@ -3312,21 +3473,39 @@ module Api
|
|
3312
3473
|
end
|
3313
3474
|
|
3314
3475
|
val = @radius
|
3315
|
-
if
|
3476
|
+
if has_radius?
|
3316
3477
|
buff << 0x15
|
3317
3478
|
|
3318
3479
|
[val].pack("e", buffer: buff)
|
3319
3480
|
end
|
3320
|
-
|
3481
|
+
buff << @_unknown_fields if @_unknown_fields
|
3321
3482
|
buff
|
3322
3483
|
end
|
3323
3484
|
|
3324
3485
|
def to_h
|
3325
3486
|
result = {}
|
3326
|
-
|
3327
|
-
result["
|
3487
|
+
|
3488
|
+
result[:"pos"] = @pos.to_h
|
3489
|
+
result[:"radius"] = @radius
|
3490
|
+
|
3491
|
+
result
|
3492
|
+
end
|
3493
|
+
|
3494
|
+
def as_json(options = {})
|
3495
|
+
result = {}
|
3496
|
+
|
3497
|
+
result["pos"] = @pos.nil? ? {} : @pos.as_json(options) if !options[
|
3498
|
+
:compact
|
3499
|
+
] || has_pos?
|
3500
|
+
result["radius"] = @radius if !options[:compact] || has_radius?
|
3501
|
+
|
3328
3502
|
result
|
3329
3503
|
end
|
3504
|
+
|
3505
|
+
def to_json(as_json_options = {})
|
3506
|
+
require "json"
|
3507
|
+
JSON.dump(as_json(as_json_options))
|
3508
|
+
end
|
3330
3509
|
end
|
3331
3510
|
class PowerSource
|
3332
3511
|
def self.decode(buff)
|
@@ -3480,20 +3659,39 @@ module Api
|
|
3480
3659
|
# unexpected, so discard it and continue.
|
3481
3660
|
if !found
|
3482
3661
|
wire_type = tag & 0x7
|
3662
|
+
|
3663
|
+
unknown_bytes = +"".b
|
3664
|
+
val = tag
|
3665
|
+
loop do
|
3666
|
+
byte = val & 0x7F
|
3667
|
+
|
3668
|
+
val >>= 7
|
3669
|
+
# This drops the top bits,
|
3670
|
+
# Otherwise, with a signed right shift,
|
3671
|
+
# we get infinity one bits at the top
|
3672
|
+
val &= (1 << 57) - 1
|
3673
|
+
|
3674
|
+
byte |= 0x80 if val != 0
|
3675
|
+
unknown_bytes << byte
|
3676
|
+
break if val == 0
|
3677
|
+
end
|
3678
|
+
|
3483
3679
|
case wire_type
|
3484
3680
|
when 0
|
3485
3681
|
i = 0
|
3486
3682
|
while true
|
3487
3683
|
newbyte = buff.getbyte(index)
|
3488
3684
|
index += 1
|
3489
|
-
break if newbyte.nil?
|
3685
|
+
break if newbyte.nil?
|
3686
|
+
unknown_bytes << newbyte
|
3687
|
+
break if newbyte < 0x80
|
3490
3688
|
i += 1
|
3491
3689
|
break if i > 9
|
3492
3690
|
end
|
3493
3691
|
when 1
|
3692
|
+
unknown_bytes << buff.byteslice(index, 8)
|
3494
3693
|
index += 8
|
3495
3694
|
when 2
|
3496
|
-
## PULL_BYTES
|
3497
3695
|
value =
|
3498
3696
|
if (byte0 = buff.getbyte(index)) < 0x80
|
3499
3697
|
index += 1
|
@@ -3549,15 +3747,30 @@ module Api
|
|
3549
3747
|
raise "integer decoding error"
|
3550
3748
|
end
|
3551
3749
|
|
3552
|
-
|
3553
|
-
|
3750
|
+
val = value
|
3751
|
+
loop do
|
3752
|
+
byte = val & 0x7F
|
3554
3753
|
|
3555
|
-
|
3754
|
+
val >>= 7
|
3755
|
+
# This drops the top bits,
|
3756
|
+
# Otherwise, with a signed right shift,
|
3757
|
+
# we get infinity one bits at the top
|
3758
|
+
val &= (1 << 57) - 1
|
3759
|
+
|
3760
|
+
byte |= 0x80 if val != 0
|
3761
|
+
unknown_bytes << byte
|
3762
|
+
break if val == 0
|
3763
|
+
end
|
3764
|
+
|
3765
|
+
unknown_bytes << buff.byteslice(index, value)
|
3766
|
+
index += value
|
3556
3767
|
when 5
|
3768
|
+
unknown_bytes << buff.byteslice(index, 4)
|
3557
3769
|
index += 4
|
3558
3770
|
else
|
3559
3771
|
raise "unknown wire type #{wire_type}"
|
3560
3772
|
end
|
3773
|
+
(@_unknown_fields ||= +"".b) << unknown_bytes
|
3561
3774
|
return self if index >= len
|
3562
3775
|
## PULL_UINT64
|
3563
3776
|
tag =
|
@@ -3945,34 +4158,54 @@ module Api
|
|
3945
4158
|
end
|
3946
4159
|
|
3947
4160
|
val = @radius
|
3948
|
-
if
|
4161
|
+
if has_radius?
|
3949
4162
|
buff << 0x15
|
3950
4163
|
|
3951
4164
|
[val].pack("e", buffer: buff)
|
3952
4165
|
end
|
3953
4166
|
|
3954
4167
|
val = @tag
|
3955
|
-
if
|
4168
|
+
if has_tag?
|
3956
4169
|
buff << 0x18
|
3957
4170
|
|
3958
|
-
|
4171
|
+
loop do
|
3959
4172
|
byte = val & 0x7F
|
3960
4173
|
val >>= 7
|
3961
4174
|
byte |= 0x80 if val > 0
|
3962
4175
|
buff << byte
|
4176
|
+
break if val == 0
|
3963
4177
|
end
|
3964
4178
|
end
|
3965
|
-
|
4179
|
+
buff << @_unknown_fields if @_unknown_fields
|
3966
4180
|
buff
|
3967
4181
|
end
|
3968
4182
|
|
3969
4183
|
def to_h
|
3970
4184
|
result = {}
|
3971
|
-
|
3972
|
-
result["
|
3973
|
-
result["
|
4185
|
+
|
4186
|
+
result[:"pos"] = @pos.to_h
|
4187
|
+
result[:"radius"] = @radius
|
4188
|
+
result[:"tag"] = @tag
|
4189
|
+
|
4190
|
+
result
|
4191
|
+
end
|
4192
|
+
|
4193
|
+
def as_json(options = {})
|
4194
|
+
result = {}
|
4195
|
+
|
4196
|
+
result["pos"] = @pos.nil? ? {} : @pos.as_json(options) if !options[
|
4197
|
+
:compact
|
4198
|
+
] || has_pos?
|
4199
|
+
result["radius"] = @radius if !options[:compact] || has_radius?
|
4200
|
+
result["tag"] = @tag if !options[:compact] || has_tag?
|
4201
|
+
|
3974
4202
|
result
|
3975
4203
|
end
|
4204
|
+
|
4205
|
+
def to_json(as_json_options = {})
|
4206
|
+
require "json"
|
4207
|
+
JSON.dump(as_json(as_json_options))
|
4208
|
+
end
|
3976
4209
|
end
|
3977
4210
|
class PlayerRaw
|
3978
4211
|
def self.decode(buff)
|
@@ -4110,20 +4343,39 @@ module Api
|
|
4110
4343
|
# unexpected, so discard it and continue.
|
4111
4344
|
if !found
|
4112
4345
|
wire_type = tag & 0x7
|
4346
|
+
|
4347
|
+
unknown_bytes = +"".b
|
4348
|
+
val = tag
|
4349
|
+
loop do
|
4350
|
+
byte = val & 0x7F
|
4351
|
+
|
4352
|
+
val >>= 7
|
4353
|
+
# This drops the top bits,
|
4354
|
+
# Otherwise, with a signed right shift,
|
4355
|
+
# we get infinity one bits at the top
|
4356
|
+
val &= (1 << 57) - 1
|
4357
|
+
|
4358
|
+
byte |= 0x80 if val != 0
|
4359
|
+
unknown_bytes << byte
|
4360
|
+
break if val == 0
|
4361
|
+
end
|
4362
|
+
|
4113
4363
|
case wire_type
|
4114
4364
|
when 0
|
4115
4365
|
i = 0
|
4116
4366
|
while true
|
4117
4367
|
newbyte = buff.getbyte(index)
|
4118
4368
|
index += 1
|
4119
|
-
break if newbyte.nil?
|
4369
|
+
break if newbyte.nil?
|
4370
|
+
unknown_bytes << newbyte
|
4371
|
+
break if newbyte < 0x80
|
4120
4372
|
i += 1
|
4121
4373
|
break if i > 9
|
4122
4374
|
end
|
4123
4375
|
when 1
|
4376
|
+
unknown_bytes << buff.byteslice(index, 8)
|
4124
4377
|
index += 8
|
4125
4378
|
when 2
|
4126
|
-
## PULL_BYTES
|
4127
4379
|
value =
|
4128
4380
|
if (byte0 = buff.getbyte(index)) < 0x80
|
4129
4381
|
index += 1
|
@@ -4179,15 +4431,30 @@ module Api
|
|
4179
4431
|
raise "integer decoding error"
|
4180
4432
|
end
|
4181
4433
|
|
4182
|
-
|
4183
|
-
|
4434
|
+
val = value
|
4435
|
+
loop do
|
4436
|
+
byte = val & 0x7F
|
4184
4437
|
|
4185
|
-
|
4438
|
+
val >>= 7
|
4439
|
+
# This drops the top bits,
|
4440
|
+
# Otherwise, with a signed right shift,
|
4441
|
+
# we get infinity one bits at the top
|
4442
|
+
val &= (1 << 57) - 1
|
4443
|
+
|
4444
|
+
byte |= 0x80 if val != 0
|
4445
|
+
unknown_bytes << byte
|
4446
|
+
break if val == 0
|
4447
|
+
end
|
4448
|
+
|
4449
|
+
unknown_bytes << buff.byteslice(index, value)
|
4450
|
+
index += value
|
4186
4451
|
when 5
|
4452
|
+
unknown_bytes << buff.byteslice(index, 4)
|
4187
4453
|
index += 4
|
4188
4454
|
else
|
4189
4455
|
raise "unknown wire type #{wire_type}"
|
4190
4456
|
end
|
4457
|
+
(@_unknown_fields ||= +"".b) << unknown_bytes
|
4191
4458
|
return self if index >= len
|
4192
4459
|
## PULL_UINT64
|
4193
4460
|
tag =
|
@@ -4492,64 +4759,11 @@ module Api
|
|
4492
4759
|
|
4493
4760
|
## END PULL_UINT64
|
4494
4761
|
end
|
4495
|
-
if tag ==
|
4762
|
+
if tag == 0x18
|
4496
4763
|
found = true
|
4497
|
-
##
|
4498
|
-
value =
|
4499
|
-
if (byte0 = buff.getbyte(index)) < 0x80
|
4500
|
-
index += 1
|
4501
|
-
byte0
|
4502
|
-
elsif (byte1 = buff.getbyte(index + 1)) < 0x80
|
4503
|
-
index += 2
|
4504
|
-
(byte1 << 7) | (byte0 & 0x7F)
|
4505
|
-
elsif (byte2 = buff.getbyte(index + 2)) < 0x80
|
4506
|
-
index += 3
|
4507
|
-
(byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
4508
|
-
elsif (byte3 = buff.getbyte(index + 3)) < 0x80
|
4509
|
-
index += 4
|
4510
|
-
(byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
4511
|
-
(byte0 & 0x7F)
|
4512
|
-
elsif (byte4 = buff.getbyte(index + 4)) < 0x80
|
4513
|
-
index += 5
|
4514
|
-
(byte4 << 28) | ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
4515
|
-
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
4516
|
-
elsif (byte5 = buff.getbyte(index + 5)) < 0x80
|
4517
|
-
index += 6
|
4518
|
-
(byte5 << 35) | ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
4519
|
-
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
4520
|
-
elsif (byte6 = buff.getbyte(index + 6)) < 0x80
|
4521
|
-
index += 7
|
4522
|
-
(byte6 << 42) | ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
4523
|
-
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
4524
|
-
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
4525
|
-
elsif (byte7 = buff.getbyte(index + 7)) < 0x80
|
4526
|
-
index += 8
|
4527
|
-
(byte7 << 49) | ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
|
4528
|
-
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
4529
|
-
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
4530
|
-
elsif (byte8 = buff.getbyte(index + 8)) < 0x80
|
4531
|
-
index += 9
|
4532
|
-
(byte8 << 56) | ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
|
4533
|
-
((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
4534
|
-
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
4535
|
-
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
4536
|
-
elsif (byte9 = buff.getbyte(index + 9)) < 0x80
|
4537
|
-
index += 10
|
4538
|
-
|
4539
|
-
(byte9 << 63) | ((byte8 & 0x7F) << 56) | ((byte7 & 0x7F) << 49) |
|
4540
|
-
((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
|
4541
|
-
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
4542
|
-
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
4543
|
-
else
|
4544
|
-
raise "integer decoding error"
|
4545
|
-
end
|
4546
|
-
|
4547
|
-
## END PULL_UINT64
|
4548
|
-
|
4549
|
-
goal = index + value
|
4764
|
+
## DECODE REPEATED
|
4550
4765
|
list = @upgrade_ids
|
4551
4766
|
while true
|
4552
|
-
break if index >= goal
|
4553
4767
|
## PULL_UINT64
|
4554
4768
|
list << if (byte0 = buff.getbyte(index)) < 0x80
|
4555
4769
|
index += 1
|
@@ -4600,60 +4814,71 @@ module Api
|
|
4600
4814
|
end
|
4601
4815
|
|
4602
4816
|
## END PULL_UINT64
|
4817
|
+
|
4818
|
+
return self if index >= len
|
4819
|
+
## PULL_UINT64
|
4820
|
+
tag =
|
4821
|
+
if (byte0 = buff.getbyte(index)) < 0x80
|
4822
|
+
index += 1
|
4823
|
+
byte0
|
4824
|
+
elsif (byte1 = buff.getbyte(index + 1)) < 0x80
|
4825
|
+
index += 2
|
4826
|
+
(byte1 << 7) | (byte0 & 0x7F)
|
4827
|
+
elsif (byte2 = buff.getbyte(index + 2)) < 0x80
|
4828
|
+
index += 3
|
4829
|
+
(byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
4830
|
+
elsif (byte3 = buff.getbyte(index + 3)) < 0x80
|
4831
|
+
index += 4
|
4832
|
+
(byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
4833
|
+
(byte0 & 0x7F)
|
4834
|
+
elsif (byte4 = buff.getbyte(index + 4)) < 0x80
|
4835
|
+
index += 5
|
4836
|
+
(byte4 << 28) | ((byte3 & 0x7F) << 21) |
|
4837
|
+
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
4838
|
+
(byte0 & 0x7F)
|
4839
|
+
elsif (byte5 = buff.getbyte(index + 5)) < 0x80
|
4840
|
+
index += 6
|
4841
|
+
(byte5 << 35) | ((byte4 & 0x7F) << 28) |
|
4842
|
+
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
4843
|
+
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
4844
|
+
elsif (byte6 = buff.getbyte(index + 6)) < 0x80
|
4845
|
+
index += 7
|
4846
|
+
(byte6 << 42) | ((byte5 & 0x7F) << 35) |
|
4847
|
+
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
4848
|
+
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
4849
|
+
(byte0 & 0x7F)
|
4850
|
+
elsif (byte7 = buff.getbyte(index + 7)) < 0x80
|
4851
|
+
index += 8
|
4852
|
+
(byte7 << 49) | ((byte6 & 0x7F) << 42) |
|
4853
|
+
((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
4854
|
+
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
4855
|
+
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
4856
|
+
elsif (byte8 = buff.getbyte(index + 8)) < 0x80
|
4857
|
+
index += 9
|
4858
|
+
(byte8 << 56) | ((byte7 & 0x7F) << 49) |
|
4859
|
+
((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
|
4860
|
+
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
4861
|
+
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
4862
|
+
(byte0 & 0x7F)
|
4863
|
+
elsif (byte9 = buff.getbyte(index + 9)) < 0x80
|
4864
|
+
index += 10
|
4865
|
+
|
4866
|
+
(byte9 << 63) | ((byte8 & 0x7F) << 56) |
|
4867
|
+
((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
|
4868
|
+
((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
4869
|
+
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
4870
|
+
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
4871
|
+
else
|
4872
|
+
raise "integer decoding error"
|
4873
|
+
end
|
4874
|
+
|
4875
|
+
## END PULL_UINT64
|
4876
|
+
|
4877
|
+
break unless tag == 0x18
|
4603
4878
|
end
|
4879
|
+
## END DECODE REPEATED
|
4604
4880
|
|
4605
4881
|
return self if index >= len
|
4606
|
-
## PULL_UINT64
|
4607
|
-
tag =
|
4608
|
-
if (byte0 = buff.getbyte(index)) < 0x80
|
4609
|
-
index += 1
|
4610
|
-
byte0
|
4611
|
-
elsif (byte1 = buff.getbyte(index + 1)) < 0x80
|
4612
|
-
index += 2
|
4613
|
-
(byte1 << 7) | (byte0 & 0x7F)
|
4614
|
-
elsif (byte2 = buff.getbyte(index + 2)) < 0x80
|
4615
|
-
index += 3
|
4616
|
-
(byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
4617
|
-
elsif (byte3 = buff.getbyte(index + 3)) < 0x80
|
4618
|
-
index += 4
|
4619
|
-
(byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
4620
|
-
(byte0 & 0x7F)
|
4621
|
-
elsif (byte4 = buff.getbyte(index + 4)) < 0x80
|
4622
|
-
index += 5
|
4623
|
-
(byte4 << 28) | ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
4624
|
-
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
4625
|
-
elsif (byte5 = buff.getbyte(index + 5)) < 0x80
|
4626
|
-
index += 6
|
4627
|
-
(byte5 << 35) | ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
4628
|
-
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
4629
|
-
elsif (byte6 = buff.getbyte(index + 6)) < 0x80
|
4630
|
-
index += 7
|
4631
|
-
(byte6 << 42) | ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
4632
|
-
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
4633
|
-
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
4634
|
-
elsif (byte7 = buff.getbyte(index + 7)) < 0x80
|
4635
|
-
index += 8
|
4636
|
-
(byte7 << 49) | ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
|
4637
|
-
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
4638
|
-
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
4639
|
-
elsif (byte8 = buff.getbyte(index + 8)) < 0x80
|
4640
|
-
index += 9
|
4641
|
-
(byte8 << 56) | ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
|
4642
|
-
((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
4643
|
-
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
4644
|
-
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
4645
|
-
elsif (byte9 = buff.getbyte(index + 9)) < 0x80
|
4646
|
-
index += 10
|
4647
|
-
|
4648
|
-
(byte9 << 63) | ((byte8 & 0x7F) << 56) | ((byte7 & 0x7F) << 49) |
|
4649
|
-
((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
|
4650
|
-
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
4651
|
-
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
4652
|
-
else
|
4653
|
-
raise "integer decoding error"
|
4654
|
-
end
|
4655
|
-
|
4656
|
-
## END PULL_UINT64
|
4657
4882
|
end
|
4658
4883
|
|
4659
4884
|
return self if index >= len
|
@@ -4763,72 +4988,62 @@ module Api
|
|
4763
4988
|
|
4764
4989
|
list = @upgrade_ids
|
4765
4990
|
if list.size > 0
|
4766
|
-
buff << 0x1a
|
4767
|
-
|
4768
|
-
# Save the buffer size before appending the repeated bytes
|
4769
|
-
current_len = buff.bytesize
|
4770
|
-
|
4771
|
-
# Write a single dummy byte to later store encoded length
|
4772
|
-
buff << 42 # "*"
|
4773
|
-
|
4774
|
-
# write each item
|
4775
4991
|
list.each do |item|
|
4776
4992
|
val = item
|
4777
4993
|
if val != 0
|
4778
|
-
|
4994
|
+
buff << 0x18
|
4995
|
+
|
4996
|
+
loop do
|
4779
4997
|
byte = val & 0x7F
|
4780
4998
|
val >>= 7
|
4781
4999
|
byte |= 0x80 if val > 0
|
4782
5000
|
buff << byte
|
5001
|
+
break if val == 0
|
4783
5002
|
end
|
4784
5003
|
end
|
4785
5004
|
end
|
5005
|
+
end
|
5006
|
+
buff << @_unknown_fields if @_unknown_fields
|
5007
|
+
buff
|
5008
|
+
end
|
4786
5009
|
|
4787
|
-
|
4788
|
-
|
5010
|
+
def to_h
|
5011
|
+
result = {}
|
4789
5012
|
|
4790
|
-
|
4791
|
-
|
4792
|
-
|
4793
|
-
byte |= 0x80 if submessage_size > 0
|
4794
|
-
buff.setbyte(current_len, byte)
|
5013
|
+
result[:"power_sources"] = @power_sources.map(&:to_h)
|
5014
|
+
result[:"camera"] = @camera.to_h
|
5015
|
+
result[:"upgrade_ids"] = @upgrade_ids
|
4795
5016
|
|
4796
|
-
|
4797
|
-
|
4798
|
-
current_len += 1
|
5017
|
+
result
|
5018
|
+
end
|
4799
5019
|
|
4800
|
-
|
4801
|
-
|
4802
|
-
remaining_size = submessage_size
|
4803
|
-
while remaining_size != 0
|
4804
|
-
remaining_size >>= 7
|
4805
|
-
encoded_int_len += 1
|
4806
|
-
end
|
5020
|
+
def as_json(options = {})
|
5021
|
+
result = {}
|
4807
5022
|
|
4808
|
-
|
4809
|
-
buff.bytesplice(current_len, 0, "*********", 0, encoded_int_len)
|
5023
|
+
tmp_power_sources = @power_sources.map { |v| v.as_json(options) }
|
4810
5024
|
|
4811
|
-
|
4812
|
-
|
4813
|
-
|
4814
|
-
|
4815
|
-
|
4816
|
-
|
4817
|
-
|
4818
|
-
|
5025
|
+
result["powerSources"] = tmp_power_sources if !options[:compact] ||
|
5026
|
+
tmp_power_sources.any?
|
5027
|
+
|
5028
|
+
result["camera"] = (
|
5029
|
+
if @camera.nil?
|
5030
|
+
{}
|
5031
|
+
else
|
5032
|
+
@camera.as_json(options)
|
4819
5033
|
end
|
4820
|
-
|
5034
|
+
) if !options[:compact] || has_camera?
|
5035
|
+
tmp_upgrade_ids = @upgrade_ids
|
4821
5036
|
|
4822
|
-
|
4823
|
-
|
5037
|
+
result["upgradeIds"] = tmp_upgrade_ids if !options[:compact] ||
|
5038
|
+
tmp_upgrade_ids.any?
|
4824
5039
|
|
4825
|
-
def to_h
|
4826
|
-
result = {}
|
4827
|
-
result["power_sources".to_sym] = @power_sources
|
4828
|
-
result["camera".to_sym] = @camera.to_h
|
4829
|
-
result["upgrade_ids".to_sym] = @upgrade_ids
|
4830
5040
|
result
|
4831
5041
|
end
|
5042
|
+
|
5043
|
+
def to_json(as_json_options = {})
|
5044
|
+
require "json"
|
5045
|
+
JSON.dump(as_json(as_json_options))
|
5046
|
+
end
|
4832
5047
|
end
|
4833
5048
|
class UnitOrder
|
4834
5049
|
def self.decode(buff)
|
@@ -5017,20 +5232,39 @@ module Api
|
|
5017
5232
|
# unexpected, so discard it and continue.
|
5018
5233
|
if !found
|
5019
5234
|
wire_type = tag & 0x7
|
5235
|
+
|
5236
|
+
unknown_bytes = +"".b
|
5237
|
+
val = tag
|
5238
|
+
loop do
|
5239
|
+
byte = val & 0x7F
|
5240
|
+
|
5241
|
+
val >>= 7
|
5242
|
+
# This drops the top bits,
|
5243
|
+
# Otherwise, with a signed right shift,
|
5244
|
+
# we get infinity one bits at the top
|
5245
|
+
val &= (1 << 57) - 1
|
5246
|
+
|
5247
|
+
byte |= 0x80 if val != 0
|
5248
|
+
unknown_bytes << byte
|
5249
|
+
break if val == 0
|
5250
|
+
end
|
5251
|
+
|
5020
5252
|
case wire_type
|
5021
5253
|
when 0
|
5022
5254
|
i = 0
|
5023
5255
|
while true
|
5024
5256
|
newbyte = buff.getbyte(index)
|
5025
5257
|
index += 1
|
5026
|
-
break if newbyte.nil?
|
5258
|
+
break if newbyte.nil?
|
5259
|
+
unknown_bytes << newbyte
|
5260
|
+
break if newbyte < 0x80
|
5027
5261
|
i += 1
|
5028
5262
|
break if i > 9
|
5029
5263
|
end
|
5030
5264
|
when 1
|
5265
|
+
unknown_bytes << buff.byteslice(index, 8)
|
5031
5266
|
index += 8
|
5032
5267
|
when 2
|
5033
|
-
## PULL_BYTES
|
5034
5268
|
value =
|
5035
5269
|
if (byte0 = buff.getbyte(index)) < 0x80
|
5036
5270
|
index += 1
|
@@ -5086,15 +5320,30 @@ module Api
|
|
5086
5320
|
raise "integer decoding error"
|
5087
5321
|
end
|
5088
5322
|
|
5089
|
-
|
5090
|
-
|
5323
|
+
val = value
|
5324
|
+
loop do
|
5325
|
+
byte = val & 0x7F
|
5326
|
+
|
5327
|
+
val >>= 7
|
5328
|
+
# This drops the top bits,
|
5329
|
+
# Otherwise, with a signed right shift,
|
5330
|
+
# we get infinity one bits at the top
|
5331
|
+
val &= (1 << 57) - 1
|
5332
|
+
|
5333
|
+
byte |= 0x80 if val != 0
|
5334
|
+
unknown_bytes << byte
|
5335
|
+
break if val == 0
|
5336
|
+
end
|
5091
5337
|
|
5092
|
-
|
5338
|
+
unknown_bytes << buff.byteslice(index, value)
|
5339
|
+
index += value
|
5093
5340
|
when 5
|
5341
|
+
unknown_bytes << buff.byteslice(index, 4)
|
5094
5342
|
index += 4
|
5095
5343
|
else
|
5096
5344
|
raise "unknown wire type #{wire_type}"
|
5097
5345
|
end
|
5346
|
+
(@_unknown_fields ||= +"".b) << unknown_bytes
|
5098
5347
|
return self if index >= len
|
5099
5348
|
## PULL_UINT64
|
5100
5349
|
tag =
|
@@ -5543,14 +5792,15 @@ module Api
|
|
5543
5792
|
end
|
5544
5793
|
def _encode(buff)
|
5545
5794
|
val = @ability_id
|
5546
|
-
if
|
5795
|
+
if has_ability_id?
|
5547
5796
|
buff << 0x08
|
5548
5797
|
|
5549
|
-
|
5798
|
+
loop do
|
5550
5799
|
byte = val & 0x7F
|
5551
5800
|
val >>= 7
|
5552
5801
|
byte |= 0x80 if val > 0
|
5553
5802
|
buff << byte
|
5803
|
+
break if val == 0
|
5554
5804
|
end
|
5555
5805
|
end
|
5556
5806
|
|
@@ -5606,31 +5856,66 @@ module Api
|
|
5606
5856
|
if val != 0
|
5607
5857
|
buff << 0x18
|
5608
5858
|
|
5609
|
-
|
5859
|
+
loop do
|
5610
5860
|
byte = val & 0x7F
|
5611
5861
|
val >>= 7
|
5612
5862
|
byte |= 0x80 if val > 0
|
5613
5863
|
buff << byte
|
5864
|
+
break if val == 0
|
5614
5865
|
end
|
5615
5866
|
end
|
5616
5867
|
|
5617
5868
|
val = @progress
|
5618
|
-
if
|
5869
|
+
if has_progress?
|
5619
5870
|
buff << 0x25
|
5620
5871
|
|
5621
5872
|
[val].pack("e", buffer: buff)
|
5622
5873
|
end
|
5623
|
-
|
5874
|
+
buff << @_unknown_fields if @_unknown_fields
|
5624
5875
|
buff
|
5625
5876
|
end
|
5626
5877
|
|
5627
5878
|
def to_h
|
5628
5879
|
result = {}
|
5629
|
-
|
5630
|
-
|
5631
|
-
|
5880
|
+
|
5881
|
+
resolved_target = self.target
|
5882
|
+
|
5883
|
+
result[:"ability_id"] = @ability_id
|
5884
|
+
result[
|
5885
|
+
:"target_world_space_pos"
|
5886
|
+
] = @target_world_space_pos.to_h if resolved_target ==
|
5887
|
+
:"target_world_space_pos"
|
5888
|
+
result[:"target_unit_tag"] = @target_unit_tag if resolved_target ==
|
5889
|
+
:"target_unit_tag"
|
5890
|
+
result[:"progress"] = @progress
|
5891
|
+
|
5892
|
+
result
|
5893
|
+
end
|
5894
|
+
|
5895
|
+
def as_json(options = {})
|
5896
|
+
result = {}
|
5897
|
+
|
5898
|
+
resolved_target = self.target
|
5899
|
+
|
5900
|
+
result["abilityId"] = @ability_id if !options[:compact] || has_ability_id?
|
5901
|
+
result["targetWorldSpacePos"] = (
|
5902
|
+
if @target_world_space_pos.nil?
|
5903
|
+
{}
|
5904
|
+
else
|
5905
|
+
@target_world_space_pos.as_json(options)
|
5906
|
+
end
|
5907
|
+
) if resolved_target == :"target_world_space_pos"
|
5908
|
+
result["targetUnitTag"] = @target_unit_tag if resolved_target ==
|
5909
|
+
:"target_unit_tag"
|
5910
|
+
result["progress"] = @progress if !options[:compact] || has_progress?
|
5911
|
+
|
5632
5912
|
result
|
5633
5913
|
end
|
5914
|
+
|
5915
|
+
def to_json(as_json_options = {})
|
5916
|
+
require "json"
|
5917
|
+
JSON.dump(as_json(as_json_options))
|
5918
|
+
end
|
5634
5919
|
end
|
5635
5920
|
class PassengerUnit
|
5636
5921
|
def self.decode(buff)
|
@@ -5897,20 +6182,39 @@ module Api
|
|
5897
6182
|
# unexpected, so discard it and continue.
|
5898
6183
|
if !found
|
5899
6184
|
wire_type = tag & 0x7
|
6185
|
+
|
6186
|
+
unknown_bytes = +"".b
|
6187
|
+
val = tag
|
6188
|
+
loop do
|
6189
|
+
byte = val & 0x7F
|
6190
|
+
|
6191
|
+
val >>= 7
|
6192
|
+
# This drops the top bits,
|
6193
|
+
# Otherwise, with a signed right shift,
|
6194
|
+
# we get infinity one bits at the top
|
6195
|
+
val &= (1 << 57) - 1
|
6196
|
+
|
6197
|
+
byte |= 0x80 if val != 0
|
6198
|
+
unknown_bytes << byte
|
6199
|
+
break if val == 0
|
6200
|
+
end
|
6201
|
+
|
5900
6202
|
case wire_type
|
5901
6203
|
when 0
|
5902
6204
|
i = 0
|
5903
6205
|
while true
|
5904
6206
|
newbyte = buff.getbyte(index)
|
5905
6207
|
index += 1
|
5906
|
-
break if newbyte.nil?
|
6208
|
+
break if newbyte.nil?
|
6209
|
+
unknown_bytes << newbyte
|
6210
|
+
break if newbyte < 0x80
|
5907
6211
|
i += 1
|
5908
6212
|
break if i > 9
|
5909
6213
|
end
|
5910
6214
|
when 1
|
6215
|
+
unknown_bytes << buff.byteslice(index, 8)
|
5911
6216
|
index += 8
|
5912
6217
|
when 2
|
5913
|
-
## PULL_BYTES
|
5914
6218
|
value =
|
5915
6219
|
if (byte0 = buff.getbyte(index)) < 0x80
|
5916
6220
|
index += 1
|
@@ -5966,15 +6270,30 @@ module Api
|
|
5966
6270
|
raise "integer decoding error"
|
5967
6271
|
end
|
5968
6272
|
|
5969
|
-
|
5970
|
-
|
6273
|
+
val = value
|
6274
|
+
loop do
|
6275
|
+
byte = val & 0x7F
|
6276
|
+
|
6277
|
+
val >>= 7
|
6278
|
+
# This drops the top bits,
|
6279
|
+
# Otherwise, with a signed right shift,
|
6280
|
+
# we get infinity one bits at the top
|
6281
|
+
val &= (1 << 57) - 1
|
6282
|
+
|
6283
|
+
byte |= 0x80 if val != 0
|
6284
|
+
unknown_bytes << byte
|
6285
|
+
break if val == 0
|
6286
|
+
end
|
5971
6287
|
|
5972
|
-
|
6288
|
+
unknown_bytes << buff.byteslice(index, value)
|
6289
|
+
index += value
|
5973
6290
|
when 5
|
6291
|
+
unknown_bytes << buff.byteslice(index, 4)
|
5974
6292
|
index += 4
|
5975
6293
|
else
|
5976
6294
|
raise "unknown wire type #{wire_type}"
|
5977
6295
|
end
|
6296
|
+
(@_unknown_fields ||= +"".b) << unknown_bytes
|
5978
6297
|
return self if index >= len
|
5979
6298
|
## PULL_UINT64
|
5980
6299
|
tag =
|
@@ -6600,86 +6919,110 @@ module Api
|
|
6600
6919
|
end
|
6601
6920
|
def _encode(buff)
|
6602
6921
|
val = @tag
|
6603
|
-
if
|
6922
|
+
if has_tag?
|
6604
6923
|
buff << 0x08
|
6605
6924
|
|
6606
|
-
|
6925
|
+
loop do
|
6607
6926
|
byte = val & 0x7F
|
6608
6927
|
val >>= 7
|
6609
6928
|
byte |= 0x80 if val > 0
|
6610
6929
|
buff << byte
|
6930
|
+
break if val == 0
|
6611
6931
|
end
|
6612
6932
|
end
|
6613
6933
|
|
6614
6934
|
val = @health
|
6615
|
-
if
|
6935
|
+
if has_health?
|
6616
6936
|
buff << 0x15
|
6617
6937
|
|
6618
6938
|
[val].pack("e", buffer: buff)
|
6619
6939
|
end
|
6620
6940
|
|
6621
6941
|
val = @health_max
|
6622
|
-
if
|
6942
|
+
if has_health_max?
|
6623
6943
|
buff << 0x1d
|
6624
6944
|
|
6625
6945
|
[val].pack("e", buffer: buff)
|
6626
6946
|
end
|
6627
6947
|
|
6628
6948
|
val = @shield
|
6629
|
-
if
|
6949
|
+
if has_shield?
|
6630
6950
|
buff << 0x25
|
6631
6951
|
|
6632
6952
|
[val].pack("e", buffer: buff)
|
6633
6953
|
end
|
6634
6954
|
|
6635
6955
|
val = @shield_max
|
6636
|
-
if
|
6956
|
+
if has_shield_max?
|
6637
6957
|
buff << 0x3d
|
6638
6958
|
|
6639
6959
|
[val].pack("e", buffer: buff)
|
6640
6960
|
end
|
6641
6961
|
|
6642
6962
|
val = @energy
|
6643
|
-
if
|
6963
|
+
if has_energy?
|
6644
6964
|
buff << 0x2d
|
6645
6965
|
|
6646
6966
|
[val].pack("e", buffer: buff)
|
6647
6967
|
end
|
6648
6968
|
|
6649
6969
|
val = @energy_max
|
6650
|
-
if
|
6970
|
+
if has_energy_max?
|
6651
6971
|
buff << 0x45
|
6652
6972
|
|
6653
6973
|
[val].pack("e", buffer: buff)
|
6654
6974
|
end
|
6655
6975
|
|
6656
6976
|
val = @unit_type
|
6657
|
-
if
|
6977
|
+
if has_unit_type?
|
6658
6978
|
buff << 0x30
|
6659
6979
|
|
6660
|
-
|
6980
|
+
loop do
|
6661
6981
|
byte = val & 0x7F
|
6662
6982
|
val >>= 7
|
6663
6983
|
byte |= 0x80 if val > 0
|
6664
6984
|
buff << byte
|
6985
|
+
break if val == 0
|
6665
6986
|
end
|
6666
6987
|
end
|
6667
|
-
|
6988
|
+
buff << @_unknown_fields if @_unknown_fields
|
6668
6989
|
buff
|
6669
6990
|
end
|
6670
6991
|
|
6671
6992
|
def to_h
|
6672
6993
|
result = {}
|
6673
|
-
|
6674
|
-
result["
|
6675
|
-
result["
|
6676
|
-
result["
|
6677
|
-
result["
|
6678
|
-
result["energy"
|
6679
|
-
result["
|
6680
|
-
result["
|
6994
|
+
|
6995
|
+
result[:"tag"] = @tag
|
6996
|
+
result[:"health"] = @health
|
6997
|
+
result[:"health_max"] = @health_max
|
6998
|
+
result[:"shield"] = @shield
|
6999
|
+
result[:"energy"] = @energy
|
7000
|
+
result[:"unit_type"] = @unit_type
|
7001
|
+
result[:"shield_max"] = @shield_max
|
7002
|
+
result[:"energy_max"] = @energy_max
|
7003
|
+
|
7004
|
+
result
|
7005
|
+
end
|
7006
|
+
|
7007
|
+
def as_json(options = {})
|
7008
|
+
result = {}
|
7009
|
+
|
7010
|
+
result["tag"] = @tag if !options[:compact] || has_tag?
|
7011
|
+
result["health"] = @health if !options[:compact] || has_health?
|
7012
|
+
result["healthMax"] = @health_max if !options[:compact] || has_health_max?
|
7013
|
+
result["shield"] = @shield if !options[:compact] || has_shield?
|
7014
|
+
result["energy"] = @energy if !options[:compact] || has_energy?
|
7015
|
+
result["unitType"] = @unit_type if !options[:compact] || has_unit_type?
|
7016
|
+
result["shieldMax"] = @shield_max if !options[:compact] || has_shield_max?
|
7017
|
+
result["energyMax"] = @energy_max if !options[:compact] || has_energy_max?
|
7018
|
+
|
6681
7019
|
result
|
6682
7020
|
end
|
7021
|
+
|
7022
|
+
def to_json(as_json_options = {})
|
7023
|
+
require "json"
|
7024
|
+
JSON.dump(as_json(as_json_options))
|
7025
|
+
end
|
6683
7026
|
end
|
6684
7027
|
class RallyTarget
|
6685
7028
|
def self.decode(buff)
|
@@ -6814,20 +7157,39 @@ module Api
|
|
6814
7157
|
# unexpected, so discard it and continue.
|
6815
7158
|
if !found
|
6816
7159
|
wire_type = tag & 0x7
|
7160
|
+
|
7161
|
+
unknown_bytes = +"".b
|
7162
|
+
val = tag
|
7163
|
+
loop do
|
7164
|
+
byte = val & 0x7F
|
7165
|
+
|
7166
|
+
val >>= 7
|
7167
|
+
# This drops the top bits,
|
7168
|
+
# Otherwise, with a signed right shift,
|
7169
|
+
# we get infinity one bits at the top
|
7170
|
+
val &= (1 << 57) - 1
|
7171
|
+
|
7172
|
+
byte |= 0x80 if val != 0
|
7173
|
+
unknown_bytes << byte
|
7174
|
+
break if val == 0
|
7175
|
+
end
|
7176
|
+
|
6817
7177
|
case wire_type
|
6818
7178
|
when 0
|
6819
7179
|
i = 0
|
6820
7180
|
while true
|
6821
7181
|
newbyte = buff.getbyte(index)
|
6822
7182
|
index += 1
|
6823
|
-
break if newbyte.nil?
|
7183
|
+
break if newbyte.nil?
|
7184
|
+
unknown_bytes << newbyte
|
7185
|
+
break if newbyte < 0x80
|
6824
7186
|
i += 1
|
6825
7187
|
break if i > 9
|
6826
7188
|
end
|
6827
7189
|
when 1
|
7190
|
+
unknown_bytes << buff.byteslice(index, 8)
|
6828
7191
|
index += 8
|
6829
7192
|
when 2
|
6830
|
-
## PULL_BYTES
|
6831
7193
|
value =
|
6832
7194
|
if (byte0 = buff.getbyte(index)) < 0x80
|
6833
7195
|
index += 1
|
@@ -6883,15 +7245,30 @@ module Api
|
|
6883
7245
|
raise "integer decoding error"
|
6884
7246
|
end
|
6885
7247
|
|
6886
|
-
|
6887
|
-
|
7248
|
+
val = value
|
7249
|
+
loop do
|
7250
|
+
byte = val & 0x7F
|
7251
|
+
|
7252
|
+
val >>= 7
|
7253
|
+
# This drops the top bits,
|
7254
|
+
# Otherwise, with a signed right shift,
|
7255
|
+
# we get infinity one bits at the top
|
7256
|
+
val &= (1 << 57) - 1
|
7257
|
+
|
7258
|
+
byte |= 0x80 if val != 0
|
7259
|
+
unknown_bytes << byte
|
7260
|
+
break if val == 0
|
7261
|
+
end
|
6888
7262
|
|
6889
|
-
|
7263
|
+
unknown_bytes << buff.byteslice(index, value)
|
7264
|
+
index += value
|
6890
7265
|
when 5
|
7266
|
+
unknown_bytes << buff.byteslice(index, 4)
|
6891
7267
|
index += 4
|
6892
7268
|
else
|
6893
7269
|
raise "unknown wire type #{wire_type}"
|
6894
7270
|
end
|
7271
|
+
(@_unknown_fields ||= +"".b) << unknown_bytes
|
6895
7272
|
return self if index >= len
|
6896
7273
|
## PULL_UINT64
|
6897
7274
|
tag =
|
@@ -7222,26 +7599,45 @@ module Api
|
|
7222
7599
|
end
|
7223
7600
|
|
7224
7601
|
val = @tag
|
7225
|
-
if
|
7602
|
+
if has_tag?
|
7226
7603
|
buff << 0x10
|
7227
7604
|
|
7228
|
-
|
7605
|
+
loop do
|
7229
7606
|
byte = val & 0x7F
|
7230
7607
|
val >>= 7
|
7231
7608
|
byte |= 0x80 if val > 0
|
7232
7609
|
buff << byte
|
7610
|
+
break if val == 0
|
7233
7611
|
end
|
7234
7612
|
end
|
7235
|
-
|
7613
|
+
buff << @_unknown_fields if @_unknown_fields
|
7236
7614
|
buff
|
7237
7615
|
end
|
7238
7616
|
|
7239
7617
|
def to_h
|
7240
7618
|
result = {}
|
7241
|
-
|
7242
|
-
result["
|
7619
|
+
|
7620
|
+
result[:"point"] = @point.to_h
|
7621
|
+
result[:"tag"] = @tag
|
7622
|
+
|
7623
|
+
result
|
7624
|
+
end
|
7625
|
+
|
7626
|
+
def as_json(options = {})
|
7627
|
+
result = {}
|
7628
|
+
|
7629
|
+
result["point"] = @point.nil? ? {} : @point.as_json(options) if !options[
|
7630
|
+
:compact
|
7631
|
+
] || has_point?
|
7632
|
+
result["tag"] = @tag if !options[:compact] || has_tag?
|
7633
|
+
|
7243
7634
|
result
|
7244
7635
|
end
|
7636
|
+
|
7637
|
+
def to_json(as_json_options = {})
|
7638
|
+
require "json"
|
7639
|
+
JSON.dump(as_json(as_json_options))
|
7640
|
+
end
|
7245
7641
|
end
|
7246
7642
|
class Unit
|
7247
7643
|
def self.decode(buff)
|
@@ -7373,12 +7769,15 @@ module Api
|
|
7373
7769
|
# enum writers
|
7374
7770
|
def display_type=(v)
|
7375
7771
|
@display_type = Api::DisplayType.resolve(v) || v
|
7772
|
+
@_bitmask |= 0x0000000000000001
|
7376
7773
|
end
|
7377
7774
|
def alliance=(v)
|
7378
7775
|
@alliance = Api::Alliance.resolve(v) || v
|
7776
|
+
@_bitmask |= 0x0000000000000002
|
7379
7777
|
end
|
7380
7778
|
def cloak=(v)
|
7381
7779
|
@cloak = Api::CloakState.resolve(v) || v
|
7780
|
+
@_bitmask |= 0x0000000000000200
|
7382
7781
|
end
|
7383
7782
|
|
7384
7783
|
# BEGIN writers for optional fields
|
@@ -8072,6 +8471,14 @@ module Api
|
|
8072
8471
|
self.class.encode(self)
|
8073
8472
|
end
|
8074
8473
|
|
8474
|
+
def has_display_type?
|
8475
|
+
(@_bitmask & 0x0000000000000001) == 0x0000000000000001
|
8476
|
+
end
|
8477
|
+
|
8478
|
+
def has_alliance?
|
8479
|
+
(@_bitmask & 0x0000000000000002) == 0x0000000000000002
|
8480
|
+
end
|
8481
|
+
|
8075
8482
|
def has_tag?
|
8076
8483
|
(@_bitmask & 0x0000000000000004) == 0x0000000000000004
|
8077
8484
|
end
|
@@ -8100,6 +8507,10 @@ module Api
|
|
8100
8507
|
(@_bitmask & 0x0000000000000100) == 0x0000000000000100
|
8101
8508
|
end
|
8102
8509
|
|
8510
|
+
def has_cloak?
|
8511
|
+
(@_bitmask & 0x0000000000000200) == 0x0000000000000200
|
8512
|
+
end
|
8513
|
+
|
8103
8514
|
def has_detect_range?
|
8104
8515
|
(@_bitmask & 0x0000000000000400) == 0x0000000000000400
|
8105
8516
|
end
|
@@ -8327,20 +8738,39 @@ module Api
|
|
8327
8738
|
# unexpected, so discard it and continue.
|
8328
8739
|
if !found
|
8329
8740
|
wire_type = tag & 0x7
|
8741
|
+
|
8742
|
+
unknown_bytes = +"".b
|
8743
|
+
val = tag
|
8744
|
+
loop do
|
8745
|
+
byte = val & 0x7F
|
8746
|
+
|
8747
|
+
val >>= 7
|
8748
|
+
# This drops the top bits,
|
8749
|
+
# Otherwise, with a signed right shift,
|
8750
|
+
# we get infinity one bits at the top
|
8751
|
+
val &= (1 << 57) - 1
|
8752
|
+
|
8753
|
+
byte |= 0x80 if val != 0
|
8754
|
+
unknown_bytes << byte
|
8755
|
+
break if val == 0
|
8756
|
+
end
|
8757
|
+
|
8330
8758
|
case wire_type
|
8331
8759
|
when 0
|
8332
8760
|
i = 0
|
8333
8761
|
while true
|
8334
8762
|
newbyte = buff.getbyte(index)
|
8335
8763
|
index += 1
|
8336
|
-
break if newbyte.nil?
|
8764
|
+
break if newbyte.nil?
|
8765
|
+
unknown_bytes << newbyte
|
8766
|
+
break if newbyte < 0x80
|
8337
8767
|
i += 1
|
8338
8768
|
break if i > 9
|
8339
8769
|
end
|
8340
8770
|
when 1
|
8771
|
+
unknown_bytes << buff.byteslice(index, 8)
|
8341
8772
|
index += 8
|
8342
8773
|
when 2
|
8343
|
-
## PULL_BYTES
|
8344
8774
|
value =
|
8345
8775
|
if (byte0 = buff.getbyte(index)) < 0x80
|
8346
8776
|
index += 1
|
@@ -8396,15 +8826,30 @@ module Api
|
|
8396
8826
|
raise "integer decoding error"
|
8397
8827
|
end
|
8398
8828
|
|
8399
|
-
|
8400
|
-
|
8829
|
+
val = value
|
8830
|
+
loop do
|
8831
|
+
byte = val & 0x7F
|
8401
8832
|
|
8402
|
-
|
8833
|
+
val >>= 7
|
8834
|
+
# This drops the top bits,
|
8835
|
+
# Otherwise, with a signed right shift,
|
8836
|
+
# we get infinity one bits at the top
|
8837
|
+
val &= (1 << 57) - 1
|
8838
|
+
|
8839
|
+
byte |= 0x80 if val != 0
|
8840
|
+
unknown_bytes << byte
|
8841
|
+
break if val == 0
|
8842
|
+
end
|
8843
|
+
|
8844
|
+
unknown_bytes << buff.byteslice(index, value)
|
8845
|
+
index += value
|
8403
8846
|
when 5
|
8847
|
+
unknown_bytes << buff.byteslice(index, 4)
|
8404
8848
|
index += 4
|
8405
8849
|
else
|
8406
8850
|
raise "unknown wire type #{wire_type}"
|
8407
8851
|
end
|
8852
|
+
(@_unknown_fields ||= +"".b) << unknown_bytes
|
8408
8853
|
return self if index >= len
|
8409
8854
|
## PULL_UINT64
|
8410
8855
|
tag =
|
@@ -9442,64 +9887,11 @@ module Api
|
|
9442
9887
|
|
9443
9888
|
## END PULL_UINT64
|
9444
9889
|
end
|
9445
|
-
if tag ==
|
9890
|
+
if tag == 0xd8
|
9446
9891
|
found = true
|
9447
|
-
##
|
9448
|
-
value =
|
9449
|
-
if (byte0 = buff.getbyte(index)) < 0x80
|
9450
|
-
index += 1
|
9451
|
-
byte0
|
9452
|
-
elsif (byte1 = buff.getbyte(index + 1)) < 0x80
|
9453
|
-
index += 2
|
9454
|
-
(byte1 << 7) | (byte0 & 0x7F)
|
9455
|
-
elsif (byte2 = buff.getbyte(index + 2)) < 0x80
|
9456
|
-
index += 3
|
9457
|
-
(byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
9458
|
-
elsif (byte3 = buff.getbyte(index + 3)) < 0x80
|
9459
|
-
index += 4
|
9460
|
-
(byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
9461
|
-
(byte0 & 0x7F)
|
9462
|
-
elsif (byte4 = buff.getbyte(index + 4)) < 0x80
|
9463
|
-
index += 5
|
9464
|
-
(byte4 << 28) | ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
9465
|
-
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
9466
|
-
elsif (byte5 = buff.getbyte(index + 5)) < 0x80
|
9467
|
-
index += 6
|
9468
|
-
(byte5 << 35) | ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
9469
|
-
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
9470
|
-
elsif (byte6 = buff.getbyte(index + 6)) < 0x80
|
9471
|
-
index += 7
|
9472
|
-
(byte6 << 42) | ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
9473
|
-
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
9474
|
-
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
9475
|
-
elsif (byte7 = buff.getbyte(index + 7)) < 0x80
|
9476
|
-
index += 8
|
9477
|
-
(byte7 << 49) | ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
|
9478
|
-
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
9479
|
-
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
9480
|
-
elsif (byte8 = buff.getbyte(index + 8)) < 0x80
|
9481
|
-
index += 9
|
9482
|
-
(byte8 << 56) | ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
|
9483
|
-
((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
9484
|
-
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
9485
|
-
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
9486
|
-
elsif (byte9 = buff.getbyte(index + 9)) < 0x80
|
9487
|
-
index += 10
|
9488
|
-
|
9489
|
-
(byte9 << 63) | ((byte8 & 0x7F) << 56) | ((byte7 & 0x7F) << 49) |
|
9490
|
-
((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
|
9491
|
-
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
9492
|
-
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
9493
|
-
else
|
9494
|
-
raise "integer decoding error"
|
9495
|
-
end
|
9496
|
-
|
9497
|
-
## END PULL_UINT64
|
9498
|
-
|
9499
|
-
goal = index + value
|
9892
|
+
## DECODE REPEATED
|
9500
9893
|
list = @buff_ids
|
9501
9894
|
while true
|
9502
|
-
break if index >= goal
|
9503
9895
|
## PULL_UINT64
|
9504
9896
|
list << if (byte0 = buff.getbyte(index)) < 0x80
|
9505
9897
|
index += 1
|
@@ -9550,60 +9942,71 @@ module Api
|
|
9550
9942
|
end
|
9551
9943
|
|
9552
9944
|
## END PULL_UINT64
|
9553
|
-
end
|
9554
9945
|
|
9555
|
-
|
9556
|
-
|
9557
|
-
|
9558
|
-
|
9559
|
-
|
9560
|
-
|
9561
|
-
|
9562
|
-
|
9563
|
-
|
9564
|
-
|
9565
|
-
|
9566
|
-
|
9567
|
-
|
9568
|
-
|
9569
|
-
|
9570
|
-
|
9571
|
-
|
9572
|
-
|
9573
|
-
|
9574
|
-
|
9575
|
-
|
9576
|
-
index
|
9577
|
-
|
9578
|
-
(
|
9579
|
-
|
9580
|
-
|
9581
|
-
(byte6
|
9582
|
-
|
9583
|
-
(
|
9584
|
-
|
9585
|
-
|
9586
|
-
|
9587
|
-
|
9588
|
-
|
9589
|
-
|
9590
|
-
|
9591
|
-
|
9592
|
-
|
9593
|
-
|
9594
|
-
|
9595
|
-
|
9596
|
-
|
9946
|
+
return self if index >= len
|
9947
|
+
## PULL_UINT64
|
9948
|
+
tag =
|
9949
|
+
if (byte0 = buff.getbyte(index)) < 0x80
|
9950
|
+
index += 1
|
9951
|
+
byte0
|
9952
|
+
elsif (byte1 = buff.getbyte(index + 1)) < 0x80
|
9953
|
+
index += 2
|
9954
|
+
(byte1 << 7) | (byte0 & 0x7F)
|
9955
|
+
elsif (byte2 = buff.getbyte(index + 2)) < 0x80
|
9956
|
+
index += 3
|
9957
|
+
(byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
9958
|
+
elsif (byte3 = buff.getbyte(index + 3)) < 0x80
|
9959
|
+
index += 4
|
9960
|
+
(byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
9961
|
+
(byte0 & 0x7F)
|
9962
|
+
elsif (byte4 = buff.getbyte(index + 4)) < 0x80
|
9963
|
+
index += 5
|
9964
|
+
(byte4 << 28) | ((byte3 & 0x7F) << 21) |
|
9965
|
+
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
9966
|
+
(byte0 & 0x7F)
|
9967
|
+
elsif (byte5 = buff.getbyte(index + 5)) < 0x80
|
9968
|
+
index += 6
|
9969
|
+
(byte5 << 35) | ((byte4 & 0x7F) << 28) |
|
9970
|
+
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
9971
|
+
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
9972
|
+
elsif (byte6 = buff.getbyte(index + 6)) < 0x80
|
9973
|
+
index += 7
|
9974
|
+
(byte6 << 42) | ((byte5 & 0x7F) << 35) |
|
9975
|
+
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
9976
|
+
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
9977
|
+
(byte0 & 0x7F)
|
9978
|
+
elsif (byte7 = buff.getbyte(index + 7)) < 0x80
|
9979
|
+
index += 8
|
9980
|
+
(byte7 << 49) | ((byte6 & 0x7F) << 42) |
|
9981
|
+
((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
9982
|
+
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
9983
|
+
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
9984
|
+
elsif (byte8 = buff.getbyte(index + 8)) < 0x80
|
9985
|
+
index += 9
|
9986
|
+
(byte8 << 56) | ((byte7 & 0x7F) << 49) |
|
9987
|
+
((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
|
9988
|
+
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
9989
|
+
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
9990
|
+
(byte0 & 0x7F)
|
9991
|
+
elsif (byte9 = buff.getbyte(index + 9)) < 0x80
|
9992
|
+
index += 10
|
9597
9993
|
|
9598
|
-
|
9599
|
-
|
9600
|
-
|
9601
|
-
|
9602
|
-
|
9603
|
-
|
9604
|
-
|
9994
|
+
(byte9 << 63) | ((byte8 & 0x7F) << 56) |
|
9995
|
+
((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
|
9996
|
+
((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
9997
|
+
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
9998
|
+
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
9999
|
+
else
|
10000
|
+
raise "integer decoding error"
|
10001
|
+
end
|
9605
10002
|
|
9606
|
-
|
10003
|
+
## END PULL_UINT64
|
10004
|
+
|
10005
|
+
break unless tag == 0xd8
|
10006
|
+
end
|
10007
|
+
## END DECODE REPEATED
|
10008
|
+
|
10009
|
+
return self if index >= len
|
9607
10010
|
end
|
9608
10011
|
if tag == 0xfd
|
9609
10012
|
found = true
|
@@ -12565,10 +12968,10 @@ module Api
|
|
12565
12968
|
end
|
12566
12969
|
def _encode(buff)
|
12567
12970
|
val = @display_type
|
12568
|
-
if
|
12971
|
+
if has_display_type?
|
12569
12972
|
buff << 0x08
|
12570
12973
|
|
12571
|
-
|
12974
|
+
loop do
|
12572
12975
|
byte = val & 0x7F
|
12573
12976
|
|
12574
12977
|
val >>= 7
|
@@ -12579,14 +12982,15 @@ module Api
|
|
12579
12982
|
|
12580
12983
|
byte |= 0x80 if val != 0
|
12581
12984
|
buff << byte
|
12985
|
+
break if val == 0
|
12582
12986
|
end
|
12583
12987
|
end
|
12584
12988
|
|
12585
12989
|
val = @alliance
|
12586
|
-
if
|
12990
|
+
if has_alliance?
|
12587
12991
|
buff << 0x10
|
12588
12992
|
|
12589
|
-
|
12993
|
+
loop do
|
12590
12994
|
byte = val & 0x7F
|
12591
12995
|
|
12592
12996
|
val >>= 7
|
@@ -12597,38 +13001,41 @@ module Api
|
|
12597
13001
|
|
12598
13002
|
byte |= 0x80 if val != 0
|
12599
13003
|
buff << byte
|
13004
|
+
break if val == 0
|
12600
13005
|
end
|
12601
13006
|
end
|
12602
13007
|
|
12603
13008
|
val = @tag
|
12604
|
-
if
|
13009
|
+
if has_tag?
|
12605
13010
|
buff << 0x18
|
12606
13011
|
|
12607
|
-
|
13012
|
+
loop do
|
12608
13013
|
byte = val & 0x7F
|
12609
13014
|
val >>= 7
|
12610
13015
|
byte |= 0x80 if val > 0
|
12611
13016
|
buff << byte
|
13017
|
+
break if val == 0
|
12612
13018
|
end
|
12613
13019
|
end
|
12614
13020
|
|
12615
13021
|
val = @unit_type
|
12616
|
-
if
|
13022
|
+
if has_unit_type?
|
12617
13023
|
buff << 0x20
|
12618
13024
|
|
12619
|
-
|
13025
|
+
loop do
|
12620
13026
|
byte = val & 0x7F
|
12621
13027
|
val >>= 7
|
12622
13028
|
byte |= 0x80 if val > 0
|
12623
13029
|
buff << byte
|
13030
|
+
break if val == 0
|
12624
13031
|
end
|
12625
13032
|
end
|
12626
13033
|
|
12627
13034
|
val = @owner
|
12628
|
-
if
|
13035
|
+
if has_owner?
|
12629
13036
|
buff << 0x28
|
12630
13037
|
|
12631
|
-
|
13038
|
+
loop do
|
12632
13039
|
byte = val & 0x7F
|
12633
13040
|
|
12634
13041
|
val >>= 7
|
@@ -12639,6 +13046,7 @@ module Api
|
|
12639
13046
|
|
12640
13047
|
byte |= 0x80 if val != 0
|
12641
13048
|
buff << byte
|
13049
|
+
break if val == 0
|
12642
13050
|
end
|
12643
13051
|
end
|
12644
13052
|
|
@@ -12691,31 +13099,31 @@ module Api
|
|
12691
13099
|
end
|
12692
13100
|
|
12693
13101
|
val = @facing
|
12694
|
-
if
|
13102
|
+
if has_facing?
|
12695
13103
|
buff << 0x3d
|
12696
13104
|
|
12697
13105
|
[val].pack("e", buffer: buff)
|
12698
13106
|
end
|
12699
13107
|
|
12700
13108
|
val = @radius
|
12701
|
-
if
|
13109
|
+
if has_radius?
|
12702
13110
|
buff << 0x45
|
12703
13111
|
|
12704
13112
|
[val].pack("e", buffer: buff)
|
12705
13113
|
end
|
12706
13114
|
|
12707
13115
|
val = @build_progress
|
12708
|
-
if
|
13116
|
+
if has_build_progress?
|
12709
13117
|
buff << 0x4d
|
12710
13118
|
|
12711
13119
|
[val].pack("e", buffer: buff)
|
12712
13120
|
end
|
12713
13121
|
|
12714
13122
|
val = @cloak
|
12715
|
-
if
|
13123
|
+
if has_cloak?
|
12716
13124
|
buff << 0x50
|
12717
13125
|
|
12718
|
-
|
13126
|
+
loop do
|
12719
13127
|
byte = val & 0x7F
|
12720
13128
|
|
12721
13129
|
val >>= 7
|
@@ -12726,70 +13134,31 @@ module Api
|
|
12726
13134
|
|
12727
13135
|
byte |= 0x80 if val != 0
|
12728
13136
|
buff << byte
|
13137
|
+
break if val == 0
|
12729
13138
|
end
|
12730
13139
|
end
|
12731
13140
|
|
12732
13141
|
list = @buff_ids
|
12733
13142
|
if list.size > 0
|
12734
|
-
buff << 0xda
|
12735
|
-
buff << 0x01
|
12736
|
-
|
12737
|
-
# Save the buffer size before appending the repeated bytes
|
12738
|
-
current_len = buff.bytesize
|
12739
|
-
|
12740
|
-
# Write a single dummy byte to later store encoded length
|
12741
|
-
buff << 42 # "*"
|
12742
|
-
|
12743
|
-
# write each item
|
12744
13143
|
list.each do |item|
|
12745
13144
|
val = item
|
12746
13145
|
if val != 0
|
12747
|
-
|
13146
|
+
buff << 0xd8
|
13147
|
+
buff << 0x01
|
13148
|
+
|
13149
|
+
loop do
|
12748
13150
|
byte = val & 0x7F
|
12749
13151
|
val >>= 7
|
12750
13152
|
byte |= 0x80 if val > 0
|
12751
13153
|
buff << byte
|
13154
|
+
break if val == 0
|
12752
13155
|
end
|
12753
13156
|
end
|
12754
13157
|
end
|
12755
|
-
|
12756
|
-
# Calculate the submessage's size
|
12757
|
-
submessage_size = buff.bytesize - current_len - 1
|
12758
|
-
|
12759
|
-
# Hope the size fits in one byte
|
12760
|
-
byte = submessage_size & 0x7F
|
12761
|
-
submessage_size >>= 7
|
12762
|
-
byte |= 0x80 if submessage_size > 0
|
12763
|
-
buff.setbyte(current_len, byte)
|
12764
|
-
|
12765
|
-
# If the sub message was bigger
|
12766
|
-
if submessage_size > 0
|
12767
|
-
current_len += 1
|
12768
|
-
|
12769
|
-
# compute how much we need to shift
|
12770
|
-
encoded_int_len = 0
|
12771
|
-
remaining_size = submessage_size
|
12772
|
-
while remaining_size != 0
|
12773
|
-
remaining_size >>= 7
|
12774
|
-
encoded_int_len += 1
|
12775
|
-
end
|
12776
|
-
|
12777
|
-
# Make space in the string with dummy bytes
|
12778
|
-
buff.bytesplice(current_len, 0, "*********", 0, encoded_int_len)
|
12779
|
-
|
12780
|
-
# Overwrite the dummy bytes with the encoded length
|
12781
|
-
while submessage_size != 0
|
12782
|
-
byte = submessage_size & 0x7F
|
12783
|
-
submessage_size >>= 7
|
12784
|
-
byte |= 0x80 if submessage_size > 0
|
12785
|
-
buff.setbyte(current_len, byte)
|
12786
|
-
current_len += 1
|
12787
|
-
end
|
12788
|
-
end
|
12789
13158
|
end
|
12790
13159
|
|
12791
13160
|
val = @detect_range
|
12792
|
-
if
|
13161
|
+
if has_detect_range?
|
12793
13162
|
buff << 0xfd
|
12794
13163
|
buff << 0x01
|
12795
13164
|
|
@@ -12797,76 +13166,76 @@ module Api
|
|
12797
13166
|
end
|
12798
13167
|
|
12799
13168
|
val = @radar_range
|
12800
|
-
if
|
13169
|
+
if has_radar_range?
|
12801
13170
|
buff << 0x85
|
12802
13171
|
buff << 0x02
|
12803
13172
|
|
12804
13173
|
[val].pack("e", buffer: buff)
|
12805
13174
|
end
|
12806
13175
|
|
12807
|
-
|
12808
|
-
|
13176
|
+
if has_is_selected?
|
13177
|
+
val = @is_selected
|
12809
13178
|
buff << 0x58
|
12810
13179
|
|
12811
|
-
|
12812
|
-
|
12813
|
-
|
12814
|
-
|
12815
|
-
|
13180
|
+
if val == true
|
13181
|
+
buff << 1
|
13182
|
+
elsif val == false
|
13183
|
+
buff << 0
|
13184
|
+
end
|
12816
13185
|
end
|
12817
13186
|
|
12818
|
-
|
12819
|
-
|
13187
|
+
if has_is_on_screen?
|
13188
|
+
val = @is_on_screen
|
12820
13189
|
buff << 0x60
|
12821
13190
|
|
12822
|
-
|
12823
|
-
|
12824
|
-
|
12825
|
-
|
12826
|
-
|
13191
|
+
if val == true
|
13192
|
+
buff << 1
|
13193
|
+
elsif val == false
|
13194
|
+
buff << 0
|
13195
|
+
end
|
12827
13196
|
end
|
12828
13197
|
|
12829
|
-
|
12830
|
-
|
13198
|
+
if has_is_blip?
|
13199
|
+
val = @is_blip
|
12831
13200
|
buff << 0x68
|
12832
13201
|
|
12833
|
-
|
12834
|
-
|
12835
|
-
|
12836
|
-
|
12837
|
-
|
13202
|
+
if val == true
|
13203
|
+
buff << 1
|
13204
|
+
elsif val == false
|
13205
|
+
buff << 0
|
13206
|
+
end
|
12838
13207
|
end
|
12839
13208
|
|
12840
|
-
|
12841
|
-
|
13209
|
+
if has_is_powered?
|
13210
|
+
val = @is_powered
|
12842
13211
|
buff << 0x98
|
12843
13212
|
buff << 0x02
|
12844
13213
|
|
12845
|
-
|
12846
|
-
|
12847
|
-
|
12848
|
-
|
12849
|
-
|
13214
|
+
if val == true
|
13215
|
+
buff << 1
|
13216
|
+
elsif val == false
|
13217
|
+
buff << 0
|
13218
|
+
end
|
12850
13219
|
end
|
12851
13220
|
|
12852
|
-
|
12853
|
-
|
13221
|
+
if has_is_active?
|
13222
|
+
val = @is_active
|
12854
13223
|
buff << 0xb8
|
12855
13224
|
buff << 0x02
|
12856
13225
|
|
12857
|
-
|
12858
|
-
|
12859
|
-
|
12860
|
-
|
12861
|
-
|
13226
|
+
if val == true
|
13227
|
+
buff << 1
|
13228
|
+
elsif val == false
|
13229
|
+
buff << 0
|
13230
|
+
end
|
12862
13231
|
end
|
12863
13232
|
|
12864
13233
|
val = @attack_upgrade_level
|
12865
|
-
if
|
13234
|
+
if has_attack_upgrade_level?
|
12866
13235
|
buff << 0xc0
|
12867
13236
|
buff << 0x02
|
12868
13237
|
|
12869
|
-
|
13238
|
+
loop do
|
12870
13239
|
byte = val & 0x7F
|
12871
13240
|
|
12872
13241
|
val >>= 7
|
@@ -12877,15 +13246,16 @@ module Api
|
|
12877
13246
|
|
12878
13247
|
byte |= 0x80 if val != 0
|
12879
13248
|
buff << byte
|
13249
|
+
break if val == 0
|
12880
13250
|
end
|
12881
13251
|
end
|
12882
13252
|
|
12883
13253
|
val = @armor_upgrade_level
|
12884
|
-
if
|
13254
|
+
if has_armor_upgrade_level?
|
12885
13255
|
buff << 0xc8
|
12886
13256
|
buff << 0x02
|
12887
13257
|
|
12888
|
-
|
13258
|
+
loop do
|
12889
13259
|
byte = val & 0x7F
|
12890
13260
|
|
12891
13261
|
val >>= 7
|
@@ -12896,15 +13266,16 @@ module Api
|
|
12896
13266
|
|
12897
13267
|
byte |= 0x80 if val != 0
|
12898
13268
|
buff << byte
|
13269
|
+
break if val == 0
|
12899
13270
|
end
|
12900
13271
|
end
|
12901
13272
|
|
12902
13273
|
val = @shield_upgrade_level
|
12903
|
-
if
|
13274
|
+
if has_shield_upgrade_level?
|
12904
13275
|
buff << 0xd0
|
12905
13276
|
buff << 0x02
|
12906
13277
|
|
12907
|
-
|
13278
|
+
loop do
|
12908
13279
|
byte = val & 0x7F
|
12909
13280
|
|
12910
13281
|
val >>= 7
|
@@ -12915,25 +13286,26 @@ module Api
|
|
12915
13286
|
|
12916
13287
|
byte |= 0x80 if val != 0
|
12917
13288
|
buff << byte
|
13289
|
+
break if val == 0
|
12918
13290
|
end
|
12919
13291
|
end
|
12920
13292
|
|
12921
13293
|
val = @health
|
12922
|
-
if
|
13294
|
+
if has_health?
|
12923
13295
|
buff << 0x75
|
12924
13296
|
|
12925
13297
|
[val].pack("e", buffer: buff)
|
12926
13298
|
end
|
12927
13299
|
|
12928
13300
|
val = @health_max
|
12929
|
-
if
|
13301
|
+
if has_health_max?
|
12930
13302
|
buff << 0x7d
|
12931
13303
|
|
12932
13304
|
[val].pack("e", buffer: buff)
|
12933
13305
|
end
|
12934
13306
|
|
12935
13307
|
val = @shield
|
12936
|
-
if
|
13308
|
+
if has_shield?
|
12937
13309
|
buff << 0x85
|
12938
13310
|
buff << 0x01
|
12939
13311
|
|
@@ -12941,7 +13313,7 @@ module Api
|
|
12941
13313
|
end
|
12942
13314
|
|
12943
13315
|
val = @shield_max
|
12944
|
-
if
|
13316
|
+
if has_shield_max?
|
12945
13317
|
buff << 0xa5
|
12946
13318
|
buff << 0x02
|
12947
13319
|
|
@@ -12949,7 +13321,7 @@ module Api
|
|
12949
13321
|
end
|
12950
13322
|
|
12951
13323
|
val = @energy
|
12952
|
-
if
|
13324
|
+
if has_energy?
|
12953
13325
|
buff << 0x8d
|
12954
13326
|
buff << 0x01
|
12955
13327
|
|
@@ -12957,7 +13329,7 @@ module Api
|
|
12957
13329
|
end
|
12958
13330
|
|
12959
13331
|
val = @energy_max
|
12960
|
-
if
|
13332
|
+
if has_energy_max?
|
12961
13333
|
buff << 0xad
|
12962
13334
|
buff << 0x02
|
12963
13335
|
|
@@ -12965,11 +13337,11 @@ module Api
|
|
12965
13337
|
end
|
12966
13338
|
|
12967
13339
|
val = @mineral_contents
|
12968
|
-
if
|
13340
|
+
if has_mineral_contents?
|
12969
13341
|
buff << 0x90
|
12970
13342
|
buff << 0x01
|
12971
13343
|
|
12972
|
-
|
13344
|
+
loop do
|
12973
13345
|
byte = val & 0x7F
|
12974
13346
|
|
12975
13347
|
val >>= 7
|
@@ -12980,15 +13352,16 @@ module Api
|
|
12980
13352
|
|
12981
13353
|
byte |= 0x80 if val != 0
|
12982
13354
|
buff << byte
|
13355
|
+
break if val == 0
|
12983
13356
|
end
|
12984
13357
|
end
|
12985
13358
|
|
12986
13359
|
val = @vespene_contents
|
12987
|
-
if
|
13360
|
+
if has_vespene_contents?
|
12988
13361
|
buff << 0x98
|
12989
13362
|
buff << 0x01
|
12990
13363
|
|
12991
|
-
|
13364
|
+
loop do
|
12992
13365
|
byte = val & 0x7F
|
12993
13366
|
|
12994
13367
|
val >>= 7
|
@@ -12999,43 +13372,44 @@ module Api
|
|
12999
13372
|
|
13000
13373
|
byte |= 0x80 if val != 0
|
13001
13374
|
buff << byte
|
13375
|
+
break if val == 0
|
13002
13376
|
end
|
13003
13377
|
end
|
13004
13378
|
|
13005
|
-
|
13006
|
-
|
13379
|
+
if has_is_flying?
|
13380
|
+
val = @is_flying
|
13007
13381
|
buff << 0xa0
|
13008
13382
|
buff << 0x01
|
13009
13383
|
|
13010
|
-
|
13011
|
-
|
13012
|
-
|
13013
|
-
|
13014
|
-
|
13384
|
+
if val == true
|
13385
|
+
buff << 1
|
13386
|
+
elsif val == false
|
13387
|
+
buff << 0
|
13388
|
+
end
|
13015
13389
|
end
|
13016
13390
|
|
13017
|
-
|
13018
|
-
|
13391
|
+
if has_is_burrowed?
|
13392
|
+
val = @is_burrowed
|
13019
13393
|
buff << 0xa8
|
13020
13394
|
buff << 0x01
|
13021
13395
|
|
13022
|
-
|
13023
|
-
|
13024
|
-
|
13025
|
-
|
13026
|
-
|
13396
|
+
if val == true
|
13397
|
+
buff << 1
|
13398
|
+
elsif val == false
|
13399
|
+
buff << 0
|
13400
|
+
end
|
13027
13401
|
end
|
13028
13402
|
|
13029
|
-
|
13030
|
-
|
13403
|
+
if has_is_hallucination?
|
13404
|
+
val = @is_hallucination
|
13031
13405
|
buff << 0xb0
|
13032
13406
|
buff << 0x02
|
13033
13407
|
|
13034
|
-
|
13035
|
-
|
13036
|
-
|
13037
|
-
|
13038
|
-
|
13408
|
+
if val == true
|
13409
|
+
buff << 1
|
13410
|
+
elsif val == false
|
13411
|
+
buff << 0
|
13412
|
+
end
|
13039
13413
|
end
|
13040
13414
|
|
13041
13415
|
list = @orders
|
@@ -13093,15 +13467,16 @@ module Api
|
|
13093
13467
|
end
|
13094
13468
|
|
13095
13469
|
val = @add_on_tag
|
13096
|
-
if
|
13470
|
+
if has_add_on_tag?
|
13097
13471
|
buff << 0xb8
|
13098
13472
|
buff << 0x01
|
13099
13473
|
|
13100
|
-
|
13474
|
+
loop do
|
13101
13475
|
byte = val & 0x7F
|
13102
13476
|
val >>= 7
|
13103
13477
|
byte |= 0x80 if val > 0
|
13104
13478
|
buff << byte
|
13479
|
+
break if val == 0
|
13105
13480
|
end
|
13106
13481
|
end
|
13107
13482
|
|
@@ -13160,11 +13535,11 @@ module Api
|
|
13160
13535
|
end
|
13161
13536
|
|
13162
13537
|
val = @cargo_space_taken
|
13163
|
-
if
|
13538
|
+
if has_cargo_space_taken?
|
13164
13539
|
buff << 0xc8
|
13165
13540
|
buff << 0x01
|
13166
13541
|
|
13167
|
-
|
13542
|
+
loop do
|
13168
13543
|
byte = val & 0x7F
|
13169
13544
|
|
13170
13545
|
val >>= 7
|
@@ -13175,15 +13550,16 @@ module Api
|
|
13175
13550
|
|
13176
13551
|
byte |= 0x80 if val != 0
|
13177
13552
|
buff << byte
|
13553
|
+
break if val == 0
|
13178
13554
|
end
|
13179
13555
|
end
|
13180
13556
|
|
13181
13557
|
val = @cargo_space_max
|
13182
|
-
if
|
13558
|
+
if has_cargo_space_max?
|
13183
13559
|
buff << 0xd0
|
13184
13560
|
buff << 0x01
|
13185
13561
|
|
13186
|
-
|
13562
|
+
loop do
|
13187
13563
|
byte = val & 0x7F
|
13188
13564
|
|
13189
13565
|
val >>= 7
|
@@ -13194,15 +13570,16 @@ module Api
|
|
13194
13570
|
|
13195
13571
|
byte |= 0x80 if val != 0
|
13196
13572
|
buff << byte
|
13573
|
+
break if val == 0
|
13197
13574
|
end
|
13198
13575
|
end
|
13199
13576
|
|
13200
13577
|
val = @assigned_harvesters
|
13201
|
-
if
|
13578
|
+
if has_assigned_harvesters?
|
13202
13579
|
buff << 0xe0
|
13203
13580
|
buff << 0x01
|
13204
13581
|
|
13205
|
-
|
13582
|
+
loop do
|
13206
13583
|
byte = val & 0x7F
|
13207
13584
|
|
13208
13585
|
val >>= 7
|
@@ -13213,15 +13590,16 @@ module Api
|
|
13213
13590
|
|
13214
13591
|
byte |= 0x80 if val != 0
|
13215
13592
|
buff << byte
|
13593
|
+
break if val == 0
|
13216
13594
|
end
|
13217
13595
|
end
|
13218
13596
|
|
13219
13597
|
val = @ideal_harvesters
|
13220
|
-
if
|
13598
|
+
if has_ideal_harvesters?
|
13221
13599
|
buff << 0xe8
|
13222
13600
|
buff << 0x01
|
13223
13601
|
|
13224
|
-
|
13602
|
+
loop do
|
13225
13603
|
byte = val & 0x7F
|
13226
13604
|
|
13227
13605
|
val >>= 7
|
@@ -13232,11 +13610,12 @@ module Api
|
|
13232
13610
|
|
13233
13611
|
byte |= 0x80 if val != 0
|
13234
13612
|
buff << byte
|
13613
|
+
break if val == 0
|
13235
13614
|
end
|
13236
13615
|
end
|
13237
13616
|
|
13238
13617
|
val = @weapon_cooldown
|
13239
|
-
if
|
13618
|
+
if has_weapon_cooldown?
|
13240
13619
|
buff << 0xf5
|
13241
13620
|
buff << 0x01
|
13242
13621
|
|
@@ -13244,24 +13623,25 @@ module Api
|
|
13244
13623
|
end
|
13245
13624
|
|
13246
13625
|
val = @engaged_target_tag
|
13247
|
-
if
|
13626
|
+
if has_engaged_target_tag?
|
13248
13627
|
buff << 0x90
|
13249
13628
|
buff << 0x02
|
13250
13629
|
|
13251
|
-
|
13630
|
+
loop do
|
13252
13631
|
byte = val & 0x7F
|
13253
13632
|
val >>= 7
|
13254
13633
|
byte |= 0x80 if val > 0
|
13255
13634
|
buff << byte
|
13635
|
+
break if val == 0
|
13256
13636
|
end
|
13257
13637
|
end
|
13258
13638
|
|
13259
13639
|
val = @buff_duration_remain
|
13260
|
-
if
|
13640
|
+
if has_buff_duration_remain?
|
13261
13641
|
buff << 0xd8
|
13262
13642
|
buff << 0x02
|
13263
13643
|
|
13264
|
-
|
13644
|
+
loop do
|
13265
13645
|
byte = val & 0x7F
|
13266
13646
|
|
13267
13647
|
val >>= 7
|
@@ -13272,15 +13652,16 @@ module Api
|
|
13272
13652
|
|
13273
13653
|
byte |= 0x80 if val != 0
|
13274
13654
|
buff << byte
|
13655
|
+
break if val == 0
|
13275
13656
|
end
|
13276
13657
|
end
|
13277
13658
|
|
13278
13659
|
val = @buff_duration_max
|
13279
|
-
if
|
13660
|
+
if has_buff_duration_max?
|
13280
13661
|
buff << 0xe0
|
13281
13662
|
buff << 0x02
|
13282
13663
|
|
13283
|
-
|
13664
|
+
loop do
|
13284
13665
|
byte = val & 0x7F
|
13285
13666
|
|
13286
13667
|
val >>= 7
|
@@ -13291,6 +13672,7 @@ module Api
|
|
13291
13672
|
|
13292
13673
|
byte |= 0x80 if val != 0
|
13293
13674
|
buff << byte
|
13675
|
+
break if val == 0
|
13294
13676
|
end
|
13295
13677
|
end
|
13296
13678
|
|
@@ -13347,58 +13729,158 @@ module Api
|
|
13347
13729
|
end
|
13348
13730
|
end
|
13349
13731
|
end
|
13350
|
-
|
13732
|
+
buff << @_unknown_fields if @_unknown_fields
|
13351
13733
|
buff
|
13352
13734
|
end
|
13353
13735
|
|
13354
13736
|
def to_h
|
13355
13737
|
result = {}
|
13356
|
-
|
13357
|
-
result["
|
13358
|
-
result["
|
13359
|
-
result["
|
13360
|
-
result["
|
13361
|
-
result["
|
13362
|
-
result["
|
13363
|
-
result["
|
13364
|
-
result["
|
13365
|
-
result["
|
13366
|
-
result["
|
13367
|
-
result["
|
13368
|
-
result["
|
13369
|
-
result["
|
13370
|
-
result["
|
13371
|
-
result["
|
13372
|
-
result["
|
13373
|
-
result["
|
13374
|
-
result["
|
13375
|
-
result["
|
13376
|
-
result["
|
13377
|
-
result["
|
13378
|
-
result["
|
13379
|
-
result["
|
13380
|
-
result["
|
13381
|
-
result["
|
13382
|
-
result["
|
13383
|
-
result["
|
13384
|
-
result["
|
13385
|
-
result["
|
13386
|
-
result["
|
13387
|
-
result["
|
13388
|
-
result["
|
13389
|
-
result["
|
13390
|
-
result["
|
13391
|
-
result["
|
13392
|
-
result["
|
13393
|
-
result["
|
13394
|
-
result["
|
13395
|
-
result["
|
13396
|
-
result["
|
13397
|
-
result["
|
13398
|
-
result["
|
13399
|
-
result["
|
13738
|
+
|
13739
|
+
result[:"display_type"] = @display_type
|
13740
|
+
result[:"alliance"] = @alliance
|
13741
|
+
result[:"tag"] = @tag
|
13742
|
+
result[:"unit_type"] = @unit_type
|
13743
|
+
result[:"owner"] = @owner
|
13744
|
+
result[:"pos"] = @pos.to_h
|
13745
|
+
result[:"facing"] = @facing
|
13746
|
+
result[:"radius"] = @radius
|
13747
|
+
result[:"build_progress"] = @build_progress
|
13748
|
+
result[:"cloak"] = @cloak
|
13749
|
+
result[:"is_selected"] = @is_selected
|
13750
|
+
result[:"is_on_screen"] = @is_on_screen
|
13751
|
+
result[:"is_blip"] = @is_blip
|
13752
|
+
result[:"health"] = @health
|
13753
|
+
result[:"health_max"] = @health_max
|
13754
|
+
result[:"shield"] = @shield
|
13755
|
+
result[:"energy"] = @energy
|
13756
|
+
result[:"mineral_contents"] = @mineral_contents
|
13757
|
+
result[:"vespene_contents"] = @vespene_contents
|
13758
|
+
result[:"is_flying"] = @is_flying
|
13759
|
+
result[:"is_burrowed"] = @is_burrowed
|
13760
|
+
result[:"orders"] = @orders.map(&:to_h)
|
13761
|
+
result[:"add_on_tag"] = @add_on_tag
|
13762
|
+
result[:"passengers"] = @passengers.map(&:to_h)
|
13763
|
+
result[:"cargo_space_taken"] = @cargo_space_taken
|
13764
|
+
result[:"cargo_space_max"] = @cargo_space_max
|
13765
|
+
result[:"buff_ids"] = @buff_ids
|
13766
|
+
result[:"assigned_harvesters"] = @assigned_harvesters
|
13767
|
+
result[:"ideal_harvesters"] = @ideal_harvesters
|
13768
|
+
result[:"weapon_cooldown"] = @weapon_cooldown
|
13769
|
+
result[:"detect_range"] = @detect_range
|
13770
|
+
result[:"radar_range"] = @radar_range
|
13771
|
+
result[:"engaged_target_tag"] = @engaged_target_tag
|
13772
|
+
result[:"is_powered"] = @is_powered
|
13773
|
+
result[:"shield_max"] = @shield_max
|
13774
|
+
result[:"energy_max"] = @energy_max
|
13775
|
+
result[:"is_hallucination"] = @is_hallucination
|
13776
|
+
result[:"is_active"] = @is_active
|
13777
|
+
result[:"attack_upgrade_level"] = @attack_upgrade_level
|
13778
|
+
result[:"armor_upgrade_level"] = @armor_upgrade_level
|
13779
|
+
result[:"shield_upgrade_level"] = @shield_upgrade_level
|
13780
|
+
result[:"buff_duration_remain"] = @buff_duration_remain
|
13781
|
+
result[:"buff_duration_max"] = @buff_duration_max
|
13782
|
+
result[:"rally_targets"] = @rally_targets.map(&:to_h)
|
13783
|
+
|
13784
|
+
result
|
13785
|
+
end
|
13786
|
+
|
13787
|
+
def as_json(options = {})
|
13788
|
+
result = {}
|
13789
|
+
|
13790
|
+
result["displayType"] = @display_type if !options[:compact] ||
|
13791
|
+
has_display_type?
|
13792
|
+
result["alliance"] = @alliance if !options[:compact] || has_alliance?
|
13793
|
+
result["tag"] = @tag if !options[:compact] || has_tag?
|
13794
|
+
result["unitType"] = @unit_type if !options[:compact] || has_unit_type?
|
13795
|
+
result["owner"] = @owner if !options[:compact] || has_owner?
|
13796
|
+
result["pos"] = @pos.nil? ? {} : @pos.as_json(options) if !options[
|
13797
|
+
:compact
|
13798
|
+
] || has_pos?
|
13799
|
+
result["facing"] = @facing if !options[:compact] || has_facing?
|
13800
|
+
result["radius"] = @radius if !options[:compact] || has_radius?
|
13801
|
+
result["buildProgress"] = @build_progress if !options[:compact] ||
|
13802
|
+
has_build_progress?
|
13803
|
+
result["cloak"] = @cloak if !options[:compact] || has_cloak?
|
13804
|
+
result["isSelected"] = @is_selected if !options[:compact] ||
|
13805
|
+
has_is_selected?
|
13806
|
+
result["isOnScreen"] = @is_on_screen if !options[:compact] ||
|
13807
|
+
has_is_on_screen?
|
13808
|
+
result["isBlip"] = @is_blip if !options[:compact] || has_is_blip?
|
13809
|
+
result["health"] = @health if !options[:compact] || has_health?
|
13810
|
+
result["healthMax"] = @health_max if !options[:compact] || has_health_max?
|
13811
|
+
result["shield"] = @shield if !options[:compact] || has_shield?
|
13812
|
+
result["energy"] = @energy if !options[:compact] || has_energy?
|
13813
|
+
result["mineralContents"] = @mineral_contents if !options[:compact] ||
|
13814
|
+
has_mineral_contents?
|
13815
|
+
result["vespeneContents"] = @vespene_contents if !options[:compact] ||
|
13816
|
+
has_vespene_contents?
|
13817
|
+
result["isFlying"] = @is_flying if !options[:compact] || has_is_flying?
|
13818
|
+
result["isBurrowed"] = @is_burrowed if !options[:compact] ||
|
13819
|
+
has_is_burrowed?
|
13820
|
+
tmp_orders = @orders.map { |v| v.as_json(options) }
|
13821
|
+
|
13822
|
+
result["orders"] = tmp_orders if !options[:compact] || tmp_orders.any?
|
13823
|
+
|
13824
|
+
result["addOnTag"] = @add_on_tag if !options[:compact] || has_add_on_tag?
|
13825
|
+
tmp_passengers = @passengers.map { |v| v.as_json(options) }
|
13826
|
+
|
13827
|
+
result["passengers"] = tmp_passengers if !options[:compact] ||
|
13828
|
+
tmp_passengers.any?
|
13829
|
+
|
13830
|
+
result["cargoSpaceTaken"] = @cargo_space_taken if !options[:compact] ||
|
13831
|
+
has_cargo_space_taken?
|
13832
|
+
result["cargoSpaceMax"] = @cargo_space_max if !options[:compact] ||
|
13833
|
+
has_cargo_space_max?
|
13834
|
+
tmp_buff_ids = @buff_ids
|
13835
|
+
|
13836
|
+
result["buffIds"] = tmp_buff_ids if !options[:compact] ||
|
13837
|
+
tmp_buff_ids.any?
|
13838
|
+
|
13839
|
+
result["assignedHarvesters"] = @assigned_harvesters if !options[
|
13840
|
+
:compact
|
13841
|
+
] || has_assigned_harvesters?
|
13842
|
+
result["idealHarvesters"] = @ideal_harvesters if !options[:compact] ||
|
13843
|
+
has_ideal_harvesters?
|
13844
|
+
result["weaponCooldown"] = @weapon_cooldown if !options[:compact] ||
|
13845
|
+
has_weapon_cooldown?
|
13846
|
+
result["detectRange"] = @detect_range if !options[:compact] ||
|
13847
|
+
has_detect_range?
|
13848
|
+
result["radarRange"] = @radar_range if !options[:compact] ||
|
13849
|
+
has_radar_range?
|
13850
|
+
result["engagedTargetTag"] = @engaged_target_tag if !options[:compact] ||
|
13851
|
+
has_engaged_target_tag?
|
13852
|
+
result["isPowered"] = @is_powered if !options[:compact] || has_is_powered?
|
13853
|
+
result["shieldMax"] = @shield_max if !options[:compact] || has_shield_max?
|
13854
|
+
result["energyMax"] = @energy_max if !options[:compact] || has_energy_max?
|
13855
|
+
result["isHallucination"] = @is_hallucination if !options[:compact] ||
|
13856
|
+
has_is_hallucination?
|
13857
|
+
result["isActive"] = @is_active if !options[:compact] || has_is_active?
|
13858
|
+
result["attackUpgradeLevel"] = @attack_upgrade_level if !options[
|
13859
|
+
:compact
|
13860
|
+
] || has_attack_upgrade_level?
|
13861
|
+
result["armorUpgradeLevel"] = @armor_upgrade_level if !options[
|
13862
|
+
:compact
|
13863
|
+
] || has_armor_upgrade_level?
|
13864
|
+
result["shieldUpgradeLevel"] = @shield_upgrade_level if !options[
|
13865
|
+
:compact
|
13866
|
+
] || has_shield_upgrade_level?
|
13867
|
+
result["buffDurationRemain"] = @buff_duration_remain if !options[
|
13868
|
+
:compact
|
13869
|
+
] || has_buff_duration_remain?
|
13870
|
+
result["buffDurationMax"] = @buff_duration_max if !options[:compact] ||
|
13871
|
+
has_buff_duration_max?
|
13872
|
+
tmp_rally_targets = @rally_targets.map { |v| v.as_json(options) }
|
13873
|
+
|
13874
|
+
result["rallyTargets"] = tmp_rally_targets if !options[:compact] ||
|
13875
|
+
tmp_rally_targets.any?
|
13876
|
+
|
13400
13877
|
result
|
13401
13878
|
end
|
13879
|
+
|
13880
|
+
def to_json(as_json_options = {})
|
13881
|
+
require "json"
|
13882
|
+
JSON.dump(as_json(as_json_options))
|
13883
|
+
end
|
13402
13884
|
end
|
13403
13885
|
class MapState
|
13404
13886
|
def self.decode(buff)
|
@@ -13524,20 +14006,39 @@ module Api
|
|
13524
14006
|
# unexpected, so discard it and continue.
|
13525
14007
|
if !found
|
13526
14008
|
wire_type = tag & 0x7
|
14009
|
+
|
14010
|
+
unknown_bytes = +"".b
|
14011
|
+
val = tag
|
14012
|
+
loop do
|
14013
|
+
byte = val & 0x7F
|
14014
|
+
|
14015
|
+
val >>= 7
|
14016
|
+
# This drops the top bits,
|
14017
|
+
# Otherwise, with a signed right shift,
|
14018
|
+
# we get infinity one bits at the top
|
14019
|
+
val &= (1 << 57) - 1
|
14020
|
+
|
14021
|
+
byte |= 0x80 if val != 0
|
14022
|
+
unknown_bytes << byte
|
14023
|
+
break if val == 0
|
14024
|
+
end
|
14025
|
+
|
13527
14026
|
case wire_type
|
13528
14027
|
when 0
|
13529
14028
|
i = 0
|
13530
14029
|
while true
|
13531
14030
|
newbyte = buff.getbyte(index)
|
13532
14031
|
index += 1
|
13533
|
-
break if newbyte.nil?
|
14032
|
+
break if newbyte.nil?
|
14033
|
+
unknown_bytes << newbyte
|
14034
|
+
break if newbyte < 0x80
|
13534
14035
|
i += 1
|
13535
14036
|
break if i > 9
|
13536
14037
|
end
|
13537
14038
|
when 1
|
14039
|
+
unknown_bytes << buff.byteslice(index, 8)
|
13538
14040
|
index += 8
|
13539
14041
|
when 2
|
13540
|
-
## PULL_BYTES
|
13541
14042
|
value =
|
13542
14043
|
if (byte0 = buff.getbyte(index)) < 0x80
|
13543
14044
|
index += 1
|
@@ -13593,15 +14094,30 @@ module Api
|
|
13593
14094
|
raise "integer decoding error"
|
13594
14095
|
end
|
13595
14096
|
|
13596
|
-
|
13597
|
-
|
14097
|
+
val = value
|
14098
|
+
loop do
|
14099
|
+
byte = val & 0x7F
|
13598
14100
|
|
13599
|
-
|
14101
|
+
val >>= 7
|
14102
|
+
# This drops the top bits,
|
14103
|
+
# Otherwise, with a signed right shift,
|
14104
|
+
# we get infinity one bits at the top
|
14105
|
+
val &= (1 << 57) - 1
|
14106
|
+
|
14107
|
+
byte |= 0x80 if val != 0
|
14108
|
+
unknown_bytes << byte
|
14109
|
+
break if val == 0
|
14110
|
+
end
|
14111
|
+
|
14112
|
+
unknown_bytes << buff.byteslice(index, value)
|
14113
|
+
index += value
|
13600
14114
|
when 5
|
14115
|
+
unknown_bytes << buff.byteslice(index, 4)
|
13601
14116
|
index += 4
|
13602
14117
|
else
|
13603
14118
|
raise "unknown wire type #{wire_type}"
|
13604
14119
|
end
|
14120
|
+
(@_unknown_fields ||= +"".b) << unknown_bytes
|
13605
14121
|
return self if index >= len
|
13606
14122
|
## PULL_UINT64
|
13607
14123
|
tag =
|
@@ -13983,16 +14499,40 @@ module Api
|
|
13983
14499
|
|
13984
14500
|
buff
|
13985
14501
|
end
|
13986
|
-
|
14502
|
+
buff << @_unknown_fields if @_unknown_fields
|
13987
14503
|
buff
|
13988
14504
|
end
|
13989
14505
|
|
13990
14506
|
def to_h
|
13991
14507
|
result = {}
|
13992
|
-
|
13993
|
-
result["
|
14508
|
+
|
14509
|
+
result[:"visibility"] = @visibility.to_h
|
14510
|
+
result[:"creep"] = @creep.to_h
|
14511
|
+
|
14512
|
+
result
|
14513
|
+
end
|
14514
|
+
|
14515
|
+
def as_json(options = {})
|
14516
|
+
result = {}
|
14517
|
+
|
14518
|
+
result["visibility"] = (
|
14519
|
+
if @visibility.nil?
|
14520
|
+
{}
|
14521
|
+
else
|
14522
|
+
@visibility.as_json(options)
|
14523
|
+
end
|
14524
|
+
) if !options[:compact] || has_visibility?
|
14525
|
+
result["creep"] = @creep.nil? ? {} : @creep.as_json(options) if !options[
|
14526
|
+
:compact
|
14527
|
+
] || has_creep?
|
14528
|
+
|
13994
14529
|
result
|
13995
14530
|
end
|
14531
|
+
|
14532
|
+
def to_json(as_json_options = {})
|
14533
|
+
require "json"
|
14534
|
+
JSON.dump(as_json(as_json_options))
|
14535
|
+
end
|
13996
14536
|
end
|
13997
14537
|
class Event
|
13998
14538
|
def self.decode(buff)
|
@@ -14093,20 +14633,39 @@ module Api
|
|
14093
14633
|
# unexpected, so discard it and continue.
|
14094
14634
|
if !found
|
14095
14635
|
wire_type = tag & 0x7
|
14636
|
+
|
14637
|
+
unknown_bytes = +"".b
|
14638
|
+
val = tag
|
14639
|
+
loop do
|
14640
|
+
byte = val & 0x7F
|
14641
|
+
|
14642
|
+
val >>= 7
|
14643
|
+
# This drops the top bits,
|
14644
|
+
# Otherwise, with a signed right shift,
|
14645
|
+
# we get infinity one bits at the top
|
14646
|
+
val &= (1 << 57) - 1
|
14647
|
+
|
14648
|
+
byte |= 0x80 if val != 0
|
14649
|
+
unknown_bytes << byte
|
14650
|
+
break if val == 0
|
14651
|
+
end
|
14652
|
+
|
14096
14653
|
case wire_type
|
14097
14654
|
when 0
|
14098
14655
|
i = 0
|
14099
14656
|
while true
|
14100
14657
|
newbyte = buff.getbyte(index)
|
14101
14658
|
index += 1
|
14102
|
-
break if newbyte.nil?
|
14659
|
+
break if newbyte.nil?
|
14660
|
+
unknown_bytes << newbyte
|
14661
|
+
break if newbyte < 0x80
|
14103
14662
|
i += 1
|
14104
14663
|
break if i > 9
|
14105
14664
|
end
|
14106
14665
|
when 1
|
14666
|
+
unknown_bytes << buff.byteslice(index, 8)
|
14107
14667
|
index += 8
|
14108
14668
|
when 2
|
14109
|
-
## PULL_BYTES
|
14110
14669
|
value =
|
14111
14670
|
if (byte0 = buff.getbyte(index)) < 0x80
|
14112
14671
|
index += 1
|
@@ -14162,15 +14721,30 @@ module Api
|
|
14162
14721
|
raise "integer decoding error"
|
14163
14722
|
end
|
14164
14723
|
|
14165
|
-
|
14166
|
-
|
14724
|
+
val = value
|
14725
|
+
loop do
|
14726
|
+
byte = val & 0x7F
|
14167
14727
|
|
14168
|
-
|
14728
|
+
val >>= 7
|
14729
|
+
# This drops the top bits,
|
14730
|
+
# Otherwise, with a signed right shift,
|
14731
|
+
# we get infinity one bits at the top
|
14732
|
+
val &= (1 << 57) - 1
|
14733
|
+
|
14734
|
+
byte |= 0x80 if val != 0
|
14735
|
+
unknown_bytes << byte
|
14736
|
+
break if val == 0
|
14737
|
+
end
|
14738
|
+
|
14739
|
+
unknown_bytes << buff.byteslice(index, value)
|
14740
|
+
index += value
|
14169
14741
|
when 5
|
14742
|
+
unknown_bytes << buff.byteslice(index, 4)
|
14170
14743
|
index += 4
|
14171
14744
|
else
|
14172
14745
|
raise "unknown wire type #{wire_type}"
|
14173
14746
|
end
|
14747
|
+
(@_unknown_fields ||= +"".b) << unknown_bytes
|
14174
14748
|
return self if index >= len
|
14175
14749
|
## PULL_UINT64
|
14176
14750
|
tag =
|
@@ -14226,11 +14800,13 @@ module Api
|
|
14226
14800
|
end
|
14227
14801
|
found = false
|
14228
14802
|
|
14229
|
-
if tag ==
|
14803
|
+
if tag == 0x8
|
14230
14804
|
found = true
|
14231
|
-
##
|
14232
|
-
|
14233
|
-
|
14805
|
+
## DECODE REPEATED
|
14806
|
+
list = @dead_units
|
14807
|
+
while true
|
14808
|
+
## PULL_UINT64
|
14809
|
+
list << if (byte0 = buff.getbyte(index)) < 0x80
|
14234
14810
|
index += 1
|
14235
14811
|
byte0
|
14236
14812
|
elsif (byte1 = buff.getbyte(index + 1)) < 0x80
|
@@ -14278,116 +14854,72 @@ module Api
|
|
14278
14854
|
raise "integer decoding error"
|
14279
14855
|
end
|
14280
14856
|
|
14281
|
-
|
14857
|
+
## END PULL_UINT64
|
14282
14858
|
|
14283
|
-
|
14284
|
-
list = @dead_units
|
14285
|
-
while true
|
14286
|
-
break if index >= goal
|
14859
|
+
return self if index >= len
|
14287
14860
|
## PULL_UINT64
|
14288
|
-
|
14289
|
-
index
|
14290
|
-
|
14291
|
-
|
14292
|
-
index
|
14293
|
-
|
14294
|
-
|
14295
|
-
index
|
14296
|
-
|
14297
|
-
|
14298
|
-
index
|
14299
|
-
|
14300
|
-
(
|
14301
|
-
|
14302
|
-
index
|
14303
|
-
|
14304
|
-
(
|
14305
|
-
|
14306
|
-
|
14307
|
-
(byte5
|
14308
|
-
|
14309
|
-
|
14310
|
-
|
14311
|
-
|
14312
|
-
|
14313
|
-
|
14314
|
-
|
14315
|
-
|
14316
|
-
|
14317
|
-
|
14318
|
-
|
14319
|
-
|
14320
|
-
|
14321
|
-
|
14322
|
-
|
14323
|
-
|
14324
|
-
|
14325
|
-
|
14326
|
-
|
14861
|
+
tag =
|
14862
|
+
if (byte0 = buff.getbyte(index)) < 0x80
|
14863
|
+
index += 1
|
14864
|
+
byte0
|
14865
|
+
elsif (byte1 = buff.getbyte(index + 1)) < 0x80
|
14866
|
+
index += 2
|
14867
|
+
(byte1 << 7) | (byte0 & 0x7F)
|
14868
|
+
elsif (byte2 = buff.getbyte(index + 2)) < 0x80
|
14869
|
+
index += 3
|
14870
|
+
(byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
14871
|
+
elsif (byte3 = buff.getbyte(index + 3)) < 0x80
|
14872
|
+
index += 4
|
14873
|
+
(byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
14874
|
+
(byte0 & 0x7F)
|
14875
|
+
elsif (byte4 = buff.getbyte(index + 4)) < 0x80
|
14876
|
+
index += 5
|
14877
|
+
(byte4 << 28) | ((byte3 & 0x7F) << 21) |
|
14878
|
+
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
14879
|
+
(byte0 & 0x7F)
|
14880
|
+
elsif (byte5 = buff.getbyte(index + 5)) < 0x80
|
14881
|
+
index += 6
|
14882
|
+
(byte5 << 35) | ((byte4 & 0x7F) << 28) |
|
14883
|
+
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
14884
|
+
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
14885
|
+
elsif (byte6 = buff.getbyte(index + 6)) < 0x80
|
14886
|
+
index += 7
|
14887
|
+
(byte6 << 42) | ((byte5 & 0x7F) << 35) |
|
14888
|
+
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
14889
|
+
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
14890
|
+
(byte0 & 0x7F)
|
14891
|
+
elsif (byte7 = buff.getbyte(index + 7)) < 0x80
|
14892
|
+
index += 8
|
14893
|
+
(byte7 << 49) | ((byte6 & 0x7F) << 42) |
|
14894
|
+
((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
14895
|
+
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
14896
|
+
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
14897
|
+
elsif (byte8 = buff.getbyte(index + 8)) < 0x80
|
14898
|
+
index += 9
|
14899
|
+
(byte8 << 56) | ((byte7 & 0x7F) << 49) |
|
14900
|
+
((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
|
14901
|
+
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
14902
|
+
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
14903
|
+
(byte0 & 0x7F)
|
14904
|
+
elsif (byte9 = buff.getbyte(index + 9)) < 0x80
|
14905
|
+
index += 10
|
14327
14906
|
|
14328
|
-
|
14329
|
-
|
14330
|
-
|
14331
|
-
|
14332
|
-
|
14333
|
-
|
14334
|
-
|
14907
|
+
(byte9 << 63) | ((byte8 & 0x7F) << 56) |
|
14908
|
+
((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
|
14909
|
+
((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
14910
|
+
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
14911
|
+
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
14912
|
+
else
|
14913
|
+
raise "integer decoding error"
|
14914
|
+
end
|
14335
14915
|
|
14336
14916
|
## END PULL_UINT64
|
14917
|
+
|
14918
|
+
break unless tag == 0x8
|
14337
14919
|
end
|
14920
|
+
## END DECODE REPEATED
|
14338
14921
|
|
14339
14922
|
return self if index >= len
|
14340
|
-
## PULL_UINT64
|
14341
|
-
tag =
|
14342
|
-
if (byte0 = buff.getbyte(index)) < 0x80
|
14343
|
-
index += 1
|
14344
|
-
byte0
|
14345
|
-
elsif (byte1 = buff.getbyte(index + 1)) < 0x80
|
14346
|
-
index += 2
|
14347
|
-
(byte1 << 7) | (byte0 & 0x7F)
|
14348
|
-
elsif (byte2 = buff.getbyte(index + 2)) < 0x80
|
14349
|
-
index += 3
|
14350
|
-
(byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
14351
|
-
elsif (byte3 = buff.getbyte(index + 3)) < 0x80
|
14352
|
-
index += 4
|
14353
|
-
(byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
14354
|
-
(byte0 & 0x7F)
|
14355
|
-
elsif (byte4 = buff.getbyte(index + 4)) < 0x80
|
14356
|
-
index += 5
|
14357
|
-
(byte4 << 28) | ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
14358
|
-
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
14359
|
-
elsif (byte5 = buff.getbyte(index + 5)) < 0x80
|
14360
|
-
index += 6
|
14361
|
-
(byte5 << 35) | ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
14362
|
-
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
14363
|
-
elsif (byte6 = buff.getbyte(index + 6)) < 0x80
|
14364
|
-
index += 7
|
14365
|
-
(byte6 << 42) | ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
14366
|
-
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
14367
|
-
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
14368
|
-
elsif (byte7 = buff.getbyte(index + 7)) < 0x80
|
14369
|
-
index += 8
|
14370
|
-
(byte7 << 49) | ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
|
14371
|
-
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
14372
|
-
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
14373
|
-
elsif (byte8 = buff.getbyte(index + 8)) < 0x80
|
14374
|
-
index += 9
|
14375
|
-
(byte8 << 56) | ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
|
14376
|
-
((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
14377
|
-
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
14378
|
-
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
14379
|
-
elsif (byte9 = buff.getbyte(index + 9)) < 0x80
|
14380
|
-
index += 10
|
14381
|
-
|
14382
|
-
(byte9 << 63) | ((byte8 & 0x7F) << 56) | ((byte7 & 0x7F) << 49) |
|
14383
|
-
((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
|
14384
|
-
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
14385
|
-
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
14386
|
-
else
|
14387
|
-
raise "integer decoding error"
|
14388
|
-
end
|
14389
|
-
|
14390
|
-
## END PULL_UINT64
|
14391
14923
|
end
|
14392
14924
|
|
14393
14925
|
return self if index >= len
|
@@ -14396,69 +14928,47 @@ module Api
|
|
14396
14928
|
def _encode(buff)
|
14397
14929
|
list = @dead_units
|
14398
14930
|
if list.size > 0
|
14399
|
-
buff << 0x0a
|
14400
|
-
|
14401
|
-
# Save the buffer size before appending the repeated bytes
|
14402
|
-
current_len = buff.bytesize
|
14403
|
-
|
14404
|
-
# Write a single dummy byte to later store encoded length
|
14405
|
-
buff << 42 # "*"
|
14406
|
-
|
14407
|
-
# write each item
|
14408
14931
|
list.each do |item|
|
14409
14932
|
val = item
|
14410
14933
|
if val != 0
|
14411
|
-
|
14934
|
+
buff << 0x08
|
14935
|
+
|
14936
|
+
loop do
|
14412
14937
|
byte = val & 0x7F
|
14413
14938
|
val >>= 7
|
14414
14939
|
byte |= 0x80 if val > 0
|
14415
14940
|
buff << byte
|
14941
|
+
break if val == 0
|
14416
14942
|
end
|
14417
14943
|
end
|
14418
14944
|
end
|
14945
|
+
end
|
14946
|
+
buff << @_unknown_fields if @_unknown_fields
|
14947
|
+
buff
|
14948
|
+
end
|
14419
14949
|
|
14420
|
-
|
14421
|
-
|
14950
|
+
def to_h
|
14951
|
+
result = {}
|
14422
14952
|
|
14423
|
-
|
14424
|
-
byte = submessage_size & 0x7F
|
14425
|
-
submessage_size >>= 7
|
14426
|
-
byte |= 0x80 if submessage_size > 0
|
14427
|
-
buff.setbyte(current_len, byte)
|
14953
|
+
result[:"dead_units"] = @dead_units
|
14428
14954
|
|
14429
|
-
|
14430
|
-
|
14431
|
-
current_len += 1
|
14955
|
+
result
|
14956
|
+
end
|
14432
14957
|
|
14433
|
-
|
14434
|
-
|
14435
|
-
remaining_size = submessage_size
|
14436
|
-
while remaining_size != 0
|
14437
|
-
remaining_size >>= 7
|
14438
|
-
encoded_int_len += 1
|
14439
|
-
end
|
14958
|
+
def as_json(options = {})
|
14959
|
+
result = {}
|
14440
14960
|
|
14441
|
-
|
14442
|
-
buff.bytesplice(current_len, 0, "*********", 0, encoded_int_len)
|
14961
|
+
tmp_dead_units = @dead_units
|
14443
14962
|
|
14444
|
-
|
14445
|
-
|
14446
|
-
byte = submessage_size & 0x7F
|
14447
|
-
submessage_size >>= 7
|
14448
|
-
byte |= 0x80 if submessage_size > 0
|
14449
|
-
buff.setbyte(current_len, byte)
|
14450
|
-
current_len += 1
|
14451
|
-
end
|
14452
|
-
end
|
14453
|
-
end
|
14963
|
+
result["deadUnits"] = tmp_dead_units if !options[:compact] ||
|
14964
|
+
tmp_dead_units.any?
|
14454
14965
|
|
14455
|
-
|
14966
|
+
result
|
14456
14967
|
end
|
14457
14968
|
|
14458
|
-
def
|
14459
|
-
|
14460
|
-
|
14461
|
-
result
|
14969
|
+
def to_json(as_json_options = {})
|
14970
|
+
require "json"
|
14971
|
+
JSON.dump(as_json(as_json_options))
|
14462
14972
|
end
|
14463
14973
|
end
|
14464
14974
|
class Effect
|
@@ -14492,6 +15002,7 @@ module Api
|
|
14492
15002
|
# enum writers
|
14493
15003
|
def alliance=(v)
|
14494
15004
|
@alliance = Api::Alliance.resolve(v) || v
|
15005
|
+
@_bitmask |= 0x0000000000000002
|
14495
15006
|
end
|
14496
15007
|
|
14497
15008
|
# BEGIN writers for optional fields
|
@@ -14578,6 +15089,10 @@ module Api
|
|
14578
15089
|
(@_bitmask & 0x0000000000000001) == 0x0000000000000001
|
14579
15090
|
end
|
14580
15091
|
|
15092
|
+
def has_alliance?
|
15093
|
+
(@_bitmask & 0x0000000000000002) == 0x0000000000000002
|
15094
|
+
end
|
15095
|
+
|
14581
15096
|
def has_owner?
|
14582
15097
|
(@_bitmask & 0x0000000000000004) == 0x0000000000000004
|
14583
15098
|
end
|
@@ -14654,20 +15169,39 @@ module Api
|
|
14654
15169
|
# unexpected, so discard it and continue.
|
14655
15170
|
if !found
|
14656
15171
|
wire_type = tag & 0x7
|
15172
|
+
|
15173
|
+
unknown_bytes = +"".b
|
15174
|
+
val = tag
|
15175
|
+
loop do
|
15176
|
+
byte = val & 0x7F
|
15177
|
+
|
15178
|
+
val >>= 7
|
15179
|
+
# This drops the top bits,
|
15180
|
+
# Otherwise, with a signed right shift,
|
15181
|
+
# we get infinity one bits at the top
|
15182
|
+
val &= (1 << 57) - 1
|
15183
|
+
|
15184
|
+
byte |= 0x80 if val != 0
|
15185
|
+
unknown_bytes << byte
|
15186
|
+
break if val == 0
|
15187
|
+
end
|
15188
|
+
|
14657
15189
|
case wire_type
|
14658
15190
|
when 0
|
14659
15191
|
i = 0
|
14660
15192
|
while true
|
14661
15193
|
newbyte = buff.getbyte(index)
|
14662
15194
|
index += 1
|
14663
|
-
break if newbyte.nil?
|
15195
|
+
break if newbyte.nil?
|
15196
|
+
unknown_bytes << newbyte
|
15197
|
+
break if newbyte < 0x80
|
14664
15198
|
i += 1
|
14665
15199
|
break if i > 9
|
14666
15200
|
end
|
14667
15201
|
when 1
|
15202
|
+
unknown_bytes << buff.byteslice(index, 8)
|
14668
15203
|
index += 8
|
14669
15204
|
when 2
|
14670
|
-
## PULL_BYTES
|
14671
15205
|
value =
|
14672
15206
|
if (byte0 = buff.getbyte(index)) < 0x80
|
14673
15207
|
index += 1
|
@@ -14723,15 +15257,30 @@ module Api
|
|
14723
15257
|
raise "integer decoding error"
|
14724
15258
|
end
|
14725
15259
|
|
14726
|
-
|
14727
|
-
|
15260
|
+
val = value
|
15261
|
+
loop do
|
15262
|
+
byte = val & 0x7F
|
15263
|
+
|
15264
|
+
val >>= 7
|
15265
|
+
# This drops the top bits,
|
15266
|
+
# Otherwise, with a signed right shift,
|
15267
|
+
# we get infinity one bits at the top
|
15268
|
+
val &= (1 << 57) - 1
|
15269
|
+
|
15270
|
+
byte |= 0x80 if val != 0
|
15271
|
+
unknown_bytes << byte
|
15272
|
+
break if val == 0
|
15273
|
+
end
|
14728
15274
|
|
14729
|
-
|
15275
|
+
unknown_bytes << buff.byteslice(index, value)
|
15276
|
+
index += value
|
14730
15277
|
when 5
|
15278
|
+
unknown_bytes << buff.byteslice(index, 4)
|
14731
15279
|
index += 4
|
14732
15280
|
else
|
14733
15281
|
raise "unknown wire type #{wire_type}"
|
14734
15282
|
end
|
15283
|
+
(@_unknown_fields ||= +"".b) << unknown_bytes
|
14735
15284
|
return self if index >= len
|
14736
15285
|
## PULL_UINT64
|
14737
15286
|
tag =
|
@@ -15335,14 +15884,15 @@ module Api
|
|
15335
15884
|
end
|
15336
15885
|
def _encode(buff)
|
15337
15886
|
val = @effect_id
|
15338
|
-
if
|
15887
|
+
if has_effect_id?
|
15339
15888
|
buff << 0x08
|
15340
15889
|
|
15341
|
-
|
15890
|
+
loop do
|
15342
15891
|
byte = val & 0x7F
|
15343
15892
|
val >>= 7
|
15344
15893
|
byte |= 0x80 if val > 0
|
15345
15894
|
buff << byte
|
15895
|
+
break if val == 0
|
15346
15896
|
end
|
15347
15897
|
end
|
15348
15898
|
|
@@ -15400,10 +15950,10 @@ module Api
|
|
15400
15950
|
end
|
15401
15951
|
|
15402
15952
|
val = @alliance
|
15403
|
-
if
|
15953
|
+
if has_alliance?
|
15404
15954
|
buff << 0x18
|
15405
15955
|
|
15406
|
-
|
15956
|
+
loop do
|
15407
15957
|
byte = val & 0x7F
|
15408
15958
|
|
15409
15959
|
val >>= 7
|
@@ -15414,14 +15964,15 @@ module Api
|
|
15414
15964
|
|
15415
15965
|
byte |= 0x80 if val != 0
|
15416
15966
|
buff << byte
|
15967
|
+
break if val == 0
|
15417
15968
|
end
|
15418
15969
|
end
|
15419
15970
|
|
15420
15971
|
val = @owner
|
15421
|
-
if
|
15972
|
+
if has_owner?
|
15422
15973
|
buff << 0x20
|
15423
15974
|
|
15424
|
-
|
15975
|
+
loop do
|
15425
15976
|
byte = val & 0x7F
|
15426
15977
|
|
15427
15978
|
val >>= 7
|
@@ -15432,28 +15983,51 @@ module Api
|
|
15432
15983
|
|
15433
15984
|
byte |= 0x80 if val != 0
|
15434
15985
|
buff << byte
|
15986
|
+
break if val == 0
|
15435
15987
|
end
|
15436
15988
|
end
|
15437
15989
|
|
15438
15990
|
val = @radius
|
15439
|
-
if
|
15991
|
+
if has_radius?
|
15440
15992
|
buff << 0x2d
|
15441
15993
|
|
15442
15994
|
[val].pack("e", buffer: buff)
|
15443
15995
|
end
|
15444
|
-
|
15996
|
+
buff << @_unknown_fields if @_unknown_fields
|
15445
15997
|
buff
|
15446
15998
|
end
|
15447
15999
|
|
15448
16000
|
def to_h
|
15449
16001
|
result = {}
|
15450
|
-
|
15451
|
-
result["
|
15452
|
-
result["
|
15453
|
-
result["
|
15454
|
-
result["
|
16002
|
+
|
16003
|
+
result[:"effect_id"] = @effect_id
|
16004
|
+
result[:"pos"] = @pos.map(&:to_h)
|
16005
|
+
result[:"alliance"] = @alliance
|
16006
|
+
result[:"owner"] = @owner
|
16007
|
+
result[:"radius"] = @radius
|
16008
|
+
|
16009
|
+
result
|
16010
|
+
end
|
16011
|
+
|
16012
|
+
def as_json(options = {})
|
16013
|
+
result = {}
|
16014
|
+
|
16015
|
+
result["effectId"] = @effect_id if !options[:compact] || has_effect_id?
|
16016
|
+
tmp_pos = @pos.map { |v| v.as_json(options) }
|
16017
|
+
|
16018
|
+
result["pos"] = tmp_pos if !options[:compact] || tmp_pos.any?
|
16019
|
+
|
16020
|
+
result["alliance"] = @alliance if !options[:compact] || has_alliance?
|
16021
|
+
result["owner"] = @owner if !options[:compact] || has_owner?
|
16022
|
+
result["radius"] = @radius if !options[:compact] || has_radius?
|
16023
|
+
|
15455
16024
|
result
|
15456
16025
|
end
|
16026
|
+
|
16027
|
+
def to_json(as_json_options = {})
|
16028
|
+
require "json"
|
16029
|
+
JSON.dump(as_json(as_json_options))
|
16030
|
+
end
|
15457
16031
|
end
|
15458
16032
|
class ActionRaw
|
15459
16033
|
def self.decode(buff)
|
@@ -15585,20 +16159,39 @@ module Api
|
|
15585
16159
|
# unexpected, so discard it and continue.
|
15586
16160
|
if !found
|
15587
16161
|
wire_type = tag & 0x7
|
16162
|
+
|
16163
|
+
unknown_bytes = +"".b
|
16164
|
+
val = tag
|
16165
|
+
loop do
|
16166
|
+
byte = val & 0x7F
|
16167
|
+
|
16168
|
+
val >>= 7
|
16169
|
+
# This drops the top bits,
|
16170
|
+
# Otherwise, with a signed right shift,
|
16171
|
+
# we get infinity one bits at the top
|
16172
|
+
val &= (1 << 57) - 1
|
16173
|
+
|
16174
|
+
byte |= 0x80 if val != 0
|
16175
|
+
unknown_bytes << byte
|
16176
|
+
break if val == 0
|
16177
|
+
end
|
16178
|
+
|
15588
16179
|
case wire_type
|
15589
16180
|
when 0
|
15590
16181
|
i = 0
|
15591
16182
|
while true
|
15592
16183
|
newbyte = buff.getbyte(index)
|
15593
16184
|
index += 1
|
15594
|
-
break if newbyte.nil?
|
16185
|
+
break if newbyte.nil?
|
16186
|
+
unknown_bytes << newbyte
|
16187
|
+
break if newbyte < 0x80
|
15595
16188
|
i += 1
|
15596
16189
|
break if i > 9
|
15597
16190
|
end
|
15598
16191
|
when 1
|
16192
|
+
unknown_bytes << buff.byteslice(index, 8)
|
15599
16193
|
index += 8
|
15600
16194
|
when 2
|
15601
|
-
## PULL_BYTES
|
15602
16195
|
value =
|
15603
16196
|
if (byte0 = buff.getbyte(index)) < 0x80
|
15604
16197
|
index += 1
|
@@ -15654,15 +16247,30 @@ module Api
|
|
15654
16247
|
raise "integer decoding error"
|
15655
16248
|
end
|
15656
16249
|
|
15657
|
-
|
15658
|
-
|
16250
|
+
val = value
|
16251
|
+
loop do
|
16252
|
+
byte = val & 0x7F
|
16253
|
+
|
16254
|
+
val >>= 7
|
16255
|
+
# This drops the top bits,
|
16256
|
+
# Otherwise, with a signed right shift,
|
16257
|
+
# we get infinity one bits at the top
|
16258
|
+
val &= (1 << 57) - 1
|
16259
|
+
|
16260
|
+
byte |= 0x80 if val != 0
|
16261
|
+
unknown_bytes << byte
|
16262
|
+
break if val == 0
|
16263
|
+
end
|
15659
16264
|
|
15660
|
-
|
16265
|
+
unknown_bytes << buff.byteslice(index, value)
|
16266
|
+
index += value
|
15661
16267
|
when 5
|
16268
|
+
unknown_bytes << buff.byteslice(index, 4)
|
15662
16269
|
index += 4
|
15663
16270
|
else
|
15664
16271
|
raise "unknown wire type #{wire_type}"
|
15665
16272
|
end
|
16273
|
+
(@_unknown_fields ||= +"".b) << unknown_bytes
|
15666
16274
|
return self if index >= len
|
15667
16275
|
## PULL_UINT64
|
15668
16276
|
tag =
|
@@ -16217,29 +16825,73 @@ module Api
|
|
16217
16825
|
|
16218
16826
|
buff
|
16219
16827
|
end
|
16220
|
-
|
16828
|
+
buff << @_unknown_fields if @_unknown_fields
|
16221
16829
|
buff
|
16222
16830
|
end
|
16223
16831
|
|
16224
16832
|
def to_h
|
16225
16833
|
result = {}
|
16226
|
-
send("action").tap { |f| result[f.to_sym] = send(f) if f }
|
16227
|
-
result
|
16228
|
-
end
|
16229
|
-
end
|
16230
|
-
class ActionRawUnitCommand
|
16231
|
-
def self.decode(buff)
|
16232
|
-
allocate.decode_from(buff.b, 0, buff.bytesize)
|
16233
|
-
end
|
16234
16834
|
|
16235
|
-
|
16236
|
-
|
16835
|
+
resolved_action = self.action
|
16836
|
+
|
16837
|
+
result[:"unit_command"] = @unit_command.to_h if resolved_action ==
|
16838
|
+
:"unit_command"
|
16839
|
+
result[:"camera_move"] = @camera_move.to_h if resolved_action ==
|
16840
|
+
:"camera_move"
|
16841
|
+
result[:"toggle_autocast"] = @toggle_autocast.to_h if resolved_action ==
|
16842
|
+
:"toggle_autocast"
|
16843
|
+
|
16844
|
+
result
|
16237
16845
|
end
|
16238
|
-
# required field readers
|
16239
16846
|
|
16240
|
-
|
16847
|
+
def as_json(options = {})
|
16848
|
+
result = {}
|
16241
16849
|
|
16242
|
-
|
16850
|
+
resolved_action = self.action
|
16851
|
+
|
16852
|
+
result["unitCommand"] = (
|
16853
|
+
if @unit_command.nil?
|
16854
|
+
{}
|
16855
|
+
else
|
16856
|
+
@unit_command.as_json(options)
|
16857
|
+
end
|
16858
|
+
) if resolved_action == :"unit_command"
|
16859
|
+
result["cameraMove"] = (
|
16860
|
+
if @camera_move.nil?
|
16861
|
+
{}
|
16862
|
+
else
|
16863
|
+
@camera_move.as_json(options)
|
16864
|
+
end
|
16865
|
+
) if resolved_action == :"camera_move"
|
16866
|
+
result["toggleAutocast"] = (
|
16867
|
+
if @toggle_autocast.nil?
|
16868
|
+
{}
|
16869
|
+
else
|
16870
|
+
@toggle_autocast.as_json(options)
|
16871
|
+
end
|
16872
|
+
) if resolved_action == :"toggle_autocast"
|
16873
|
+
|
16874
|
+
result
|
16875
|
+
end
|
16876
|
+
|
16877
|
+
def to_json(as_json_options = {})
|
16878
|
+
require "json"
|
16879
|
+
JSON.dump(as_json(as_json_options))
|
16880
|
+
end
|
16881
|
+
end
|
16882
|
+
class ActionRawUnitCommand
|
16883
|
+
def self.decode(buff)
|
16884
|
+
allocate.decode_from(buff.b, 0, buff.bytesize)
|
16885
|
+
end
|
16886
|
+
|
16887
|
+
def self.encode(obj)
|
16888
|
+
obj._encode("".b)
|
16889
|
+
end
|
16890
|
+
# required field readers
|
16891
|
+
|
16892
|
+
attr_reader :unit_tags
|
16893
|
+
|
16894
|
+
# optional field readers
|
16243
16895
|
|
16244
16896
|
attr_reader :ability_id
|
16245
16897
|
|
@@ -16437,20 +17089,39 @@ module Api
|
|
16437
17089
|
# unexpected, so discard it and continue.
|
16438
17090
|
if !found
|
16439
17091
|
wire_type = tag & 0x7
|
17092
|
+
|
17093
|
+
unknown_bytes = +"".b
|
17094
|
+
val = tag
|
17095
|
+
loop do
|
17096
|
+
byte = val & 0x7F
|
17097
|
+
|
17098
|
+
val >>= 7
|
17099
|
+
# This drops the top bits,
|
17100
|
+
# Otherwise, with a signed right shift,
|
17101
|
+
# we get infinity one bits at the top
|
17102
|
+
val &= (1 << 57) - 1
|
17103
|
+
|
17104
|
+
byte |= 0x80 if val != 0
|
17105
|
+
unknown_bytes << byte
|
17106
|
+
break if val == 0
|
17107
|
+
end
|
17108
|
+
|
16440
17109
|
case wire_type
|
16441
17110
|
when 0
|
16442
17111
|
i = 0
|
16443
17112
|
while true
|
16444
17113
|
newbyte = buff.getbyte(index)
|
16445
17114
|
index += 1
|
16446
|
-
break if newbyte.nil?
|
17115
|
+
break if newbyte.nil?
|
17116
|
+
unknown_bytes << newbyte
|
17117
|
+
break if newbyte < 0x80
|
16447
17118
|
i += 1
|
16448
17119
|
break if i > 9
|
16449
17120
|
end
|
16450
17121
|
when 1
|
17122
|
+
unknown_bytes << buff.byteslice(index, 8)
|
16451
17123
|
index += 8
|
16452
17124
|
when 2
|
16453
|
-
## PULL_BYTES
|
16454
17125
|
value =
|
16455
17126
|
if (byte0 = buff.getbyte(index)) < 0x80
|
16456
17127
|
index += 1
|
@@ -16506,15 +17177,30 @@ module Api
|
|
16506
17177
|
raise "integer decoding error"
|
16507
17178
|
end
|
16508
17179
|
|
16509
|
-
|
16510
|
-
|
17180
|
+
val = value
|
17181
|
+
loop do
|
17182
|
+
byte = val & 0x7F
|
16511
17183
|
|
16512
|
-
|
17184
|
+
val >>= 7
|
17185
|
+
# This drops the top bits,
|
17186
|
+
# Otherwise, with a signed right shift,
|
17187
|
+
# we get infinity one bits at the top
|
17188
|
+
val &= (1 << 57) - 1
|
17189
|
+
|
17190
|
+
byte |= 0x80 if val != 0
|
17191
|
+
unknown_bytes << byte
|
17192
|
+
break if val == 0
|
17193
|
+
end
|
17194
|
+
|
17195
|
+
unknown_bytes << buff.byteslice(index, value)
|
17196
|
+
index += value
|
16513
17197
|
when 5
|
17198
|
+
unknown_bytes << buff.byteslice(index, 4)
|
16514
17199
|
index += 4
|
16515
17200
|
else
|
16516
17201
|
raise "unknown wire type #{wire_type}"
|
16517
17202
|
end
|
17203
|
+
(@_unknown_fields ||= +"".b) << unknown_bytes
|
16518
17204
|
return self if index >= len
|
16519
17205
|
## PULL_UINT64
|
16520
17206
|
tag =
|
@@ -16911,64 +17597,11 @@ module Api
|
|
16911
17597
|
|
16912
17598
|
## END PULL_UINT64
|
16913
17599
|
end
|
16914
|
-
if tag ==
|
17600
|
+
if tag == 0x20
|
16915
17601
|
found = true
|
16916
|
-
##
|
16917
|
-
value =
|
16918
|
-
if (byte0 = buff.getbyte(index)) < 0x80
|
16919
|
-
index += 1
|
16920
|
-
byte0
|
16921
|
-
elsif (byte1 = buff.getbyte(index + 1)) < 0x80
|
16922
|
-
index += 2
|
16923
|
-
(byte1 << 7) | (byte0 & 0x7F)
|
16924
|
-
elsif (byte2 = buff.getbyte(index + 2)) < 0x80
|
16925
|
-
index += 3
|
16926
|
-
(byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
16927
|
-
elsif (byte3 = buff.getbyte(index + 3)) < 0x80
|
16928
|
-
index += 4
|
16929
|
-
(byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
16930
|
-
(byte0 & 0x7F)
|
16931
|
-
elsif (byte4 = buff.getbyte(index + 4)) < 0x80
|
16932
|
-
index += 5
|
16933
|
-
(byte4 << 28) | ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
16934
|
-
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
16935
|
-
elsif (byte5 = buff.getbyte(index + 5)) < 0x80
|
16936
|
-
index += 6
|
16937
|
-
(byte5 << 35) | ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
16938
|
-
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
16939
|
-
elsif (byte6 = buff.getbyte(index + 6)) < 0x80
|
16940
|
-
index += 7
|
16941
|
-
(byte6 << 42) | ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
16942
|
-
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
16943
|
-
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
16944
|
-
elsif (byte7 = buff.getbyte(index + 7)) < 0x80
|
16945
|
-
index += 8
|
16946
|
-
(byte7 << 49) | ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
|
16947
|
-
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
16948
|
-
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
16949
|
-
elsif (byte8 = buff.getbyte(index + 8)) < 0x80
|
16950
|
-
index += 9
|
16951
|
-
(byte8 << 56) | ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
|
16952
|
-
((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
16953
|
-
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
16954
|
-
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
16955
|
-
elsif (byte9 = buff.getbyte(index + 9)) < 0x80
|
16956
|
-
index += 10
|
16957
|
-
|
16958
|
-
(byte9 << 63) | ((byte8 & 0x7F) << 56) | ((byte7 & 0x7F) << 49) |
|
16959
|
-
((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
|
16960
|
-
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
16961
|
-
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
16962
|
-
else
|
16963
|
-
raise "integer decoding error"
|
16964
|
-
end
|
16965
|
-
|
16966
|
-
## END PULL_UINT64
|
16967
|
-
|
16968
|
-
goal = index + value
|
17602
|
+
## DECODE REPEATED
|
16969
17603
|
list = @unit_tags
|
16970
17604
|
while true
|
16971
|
-
break if index >= goal
|
16972
17605
|
## PULL_UINT64
|
16973
17606
|
list << if (byte0 = buff.getbyte(index)) < 0x80
|
16974
17607
|
index += 1
|
@@ -17019,60 +17652,71 @@ module Api
|
|
17019
17652
|
end
|
17020
17653
|
|
17021
17654
|
## END PULL_UINT64
|
17022
|
-
end
|
17023
17655
|
|
17024
|
-
|
17025
|
-
|
17026
|
-
|
17027
|
-
|
17028
|
-
|
17029
|
-
|
17030
|
-
|
17031
|
-
|
17032
|
-
|
17033
|
-
|
17034
|
-
|
17035
|
-
|
17036
|
-
|
17037
|
-
|
17038
|
-
|
17039
|
-
|
17040
|
-
|
17041
|
-
|
17042
|
-
|
17043
|
-
|
17044
|
-
|
17045
|
-
index
|
17046
|
-
|
17047
|
-
(
|
17048
|
-
|
17049
|
-
|
17050
|
-
(byte6
|
17051
|
-
|
17052
|
-
(
|
17053
|
-
|
17054
|
-
|
17055
|
-
|
17056
|
-
|
17057
|
-
|
17058
|
-
|
17059
|
-
|
17060
|
-
|
17061
|
-
|
17062
|
-
|
17063
|
-
|
17064
|
-
|
17065
|
-
|
17656
|
+
return self if index >= len
|
17657
|
+
## PULL_UINT64
|
17658
|
+
tag =
|
17659
|
+
if (byte0 = buff.getbyte(index)) < 0x80
|
17660
|
+
index += 1
|
17661
|
+
byte0
|
17662
|
+
elsif (byte1 = buff.getbyte(index + 1)) < 0x80
|
17663
|
+
index += 2
|
17664
|
+
(byte1 << 7) | (byte0 & 0x7F)
|
17665
|
+
elsif (byte2 = buff.getbyte(index + 2)) < 0x80
|
17666
|
+
index += 3
|
17667
|
+
(byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
17668
|
+
elsif (byte3 = buff.getbyte(index + 3)) < 0x80
|
17669
|
+
index += 4
|
17670
|
+
(byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
17671
|
+
(byte0 & 0x7F)
|
17672
|
+
elsif (byte4 = buff.getbyte(index + 4)) < 0x80
|
17673
|
+
index += 5
|
17674
|
+
(byte4 << 28) | ((byte3 & 0x7F) << 21) |
|
17675
|
+
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
17676
|
+
(byte0 & 0x7F)
|
17677
|
+
elsif (byte5 = buff.getbyte(index + 5)) < 0x80
|
17678
|
+
index += 6
|
17679
|
+
(byte5 << 35) | ((byte4 & 0x7F) << 28) |
|
17680
|
+
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
17681
|
+
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
17682
|
+
elsif (byte6 = buff.getbyte(index + 6)) < 0x80
|
17683
|
+
index += 7
|
17684
|
+
(byte6 << 42) | ((byte5 & 0x7F) << 35) |
|
17685
|
+
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
17686
|
+
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
17687
|
+
(byte0 & 0x7F)
|
17688
|
+
elsif (byte7 = buff.getbyte(index + 7)) < 0x80
|
17689
|
+
index += 8
|
17690
|
+
(byte7 << 49) | ((byte6 & 0x7F) << 42) |
|
17691
|
+
((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
17692
|
+
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
17693
|
+
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
17694
|
+
elsif (byte8 = buff.getbyte(index + 8)) < 0x80
|
17695
|
+
index += 9
|
17696
|
+
(byte8 << 56) | ((byte7 & 0x7F) << 49) |
|
17697
|
+
((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
|
17698
|
+
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
17699
|
+
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
17700
|
+
(byte0 & 0x7F)
|
17701
|
+
elsif (byte9 = buff.getbyte(index + 9)) < 0x80
|
17702
|
+
index += 10
|
17066
17703
|
|
17067
|
-
|
17068
|
-
|
17069
|
-
|
17070
|
-
|
17071
|
-
|
17072
|
-
|
17073
|
-
|
17704
|
+
(byte9 << 63) | ((byte8 & 0x7F) << 56) |
|
17705
|
+
((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
|
17706
|
+
((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
17707
|
+
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
17708
|
+
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
17709
|
+
else
|
17710
|
+
raise "integer decoding error"
|
17711
|
+
end
|
17074
17712
|
|
17075
|
-
|
17713
|
+
## END PULL_UINT64
|
17714
|
+
|
17715
|
+
break unless tag == 0x20
|
17716
|
+
end
|
17717
|
+
## END DECODE REPEATED
|
17718
|
+
|
17719
|
+
return self if index >= len
|
17076
17720
|
end
|
17077
17721
|
if tag == 0x28
|
17078
17722
|
found = true
|
@@ -17141,10 +17785,10 @@ module Api
|
|
17141
17785
|
end
|
17142
17786
|
def _encode(buff)
|
17143
17787
|
val = @ability_id
|
17144
|
-
if
|
17788
|
+
if has_ability_id?
|
17145
17789
|
buff << 0x08
|
17146
17790
|
|
17147
|
-
|
17791
|
+
loop do
|
17148
17792
|
byte = val & 0x7F
|
17149
17793
|
|
17150
17794
|
val >>= 7
|
@@ -17155,6 +17799,7 @@ module Api
|
|
17155
17799
|
|
17156
17800
|
byte |= 0x80 if val != 0
|
17157
17801
|
buff << byte
|
17802
|
+
break if val == 0
|
17158
17803
|
end
|
17159
17804
|
end
|
17160
17805
|
|
@@ -17210,94 +17855,95 @@ module Api
|
|
17210
17855
|
if val != 0
|
17211
17856
|
buff << 0x18
|
17212
17857
|
|
17213
|
-
|
17858
|
+
loop do
|
17214
17859
|
byte = val & 0x7F
|
17215
17860
|
val >>= 7
|
17216
17861
|
byte |= 0x80 if val > 0
|
17217
17862
|
buff << byte
|
17863
|
+
break if val == 0
|
17218
17864
|
end
|
17219
17865
|
end
|
17220
17866
|
|
17221
17867
|
list = @unit_tags
|
17222
17868
|
if list.size > 0
|
17223
|
-
buff << 0x22
|
17224
|
-
|
17225
|
-
# Save the buffer size before appending the repeated bytes
|
17226
|
-
current_len = buff.bytesize
|
17227
|
-
|
17228
|
-
# Write a single dummy byte to later store encoded length
|
17229
|
-
buff << 42 # "*"
|
17230
|
-
|
17231
|
-
# write each item
|
17232
17869
|
list.each do |item|
|
17233
17870
|
val = item
|
17234
17871
|
if val != 0
|
17235
|
-
|
17872
|
+
buff << 0x20
|
17873
|
+
|
17874
|
+
loop do
|
17236
17875
|
byte = val & 0x7F
|
17237
17876
|
val >>= 7
|
17238
17877
|
byte |= 0x80 if val > 0
|
17239
17878
|
buff << byte
|
17879
|
+
break if val == 0
|
17240
17880
|
end
|
17241
17881
|
end
|
17242
17882
|
end
|
17883
|
+
end
|
17243
17884
|
|
17244
|
-
|
17245
|
-
|
17885
|
+
if has_queue_command?
|
17886
|
+
val = @queue_command
|
17887
|
+
buff << 0x28
|
17246
17888
|
|
17247
|
-
|
17248
|
-
|
17249
|
-
|
17250
|
-
|
17251
|
-
|
17889
|
+
if val == true
|
17890
|
+
buff << 1
|
17891
|
+
elsif val == false
|
17892
|
+
buff << 0
|
17893
|
+
end
|
17894
|
+
end
|
17895
|
+
buff << @_unknown_fields if @_unknown_fields
|
17896
|
+
buff
|
17897
|
+
end
|
17252
17898
|
|
17253
|
-
|
17254
|
-
|
17255
|
-
current_len += 1
|
17899
|
+
def to_h
|
17900
|
+
result = {}
|
17256
17901
|
|
17257
|
-
|
17258
|
-
encoded_int_len = 0
|
17259
|
-
remaining_size = submessage_size
|
17260
|
-
while remaining_size != 0
|
17261
|
-
remaining_size >>= 7
|
17262
|
-
encoded_int_len += 1
|
17263
|
-
end
|
17902
|
+
resolved_target = self.target
|
17264
17903
|
|
17265
|
-
|
17266
|
-
|
17904
|
+
result[:"ability_id"] = @ability_id
|
17905
|
+
result[
|
17906
|
+
:"target_world_space_pos"
|
17907
|
+
] = @target_world_space_pos.to_h if resolved_target ==
|
17908
|
+
:"target_world_space_pos"
|
17909
|
+
result[:"target_unit_tag"] = @target_unit_tag if resolved_target ==
|
17910
|
+
:"target_unit_tag"
|
17911
|
+
result[:"unit_tags"] = @unit_tags
|
17912
|
+
result[:"queue_command"] = @queue_command
|
17267
17913
|
|
17268
|
-
|
17269
|
-
|
17270
|
-
byte = submessage_size & 0x7F
|
17271
|
-
submessage_size >>= 7
|
17272
|
-
byte |= 0x80 if submessage_size > 0
|
17273
|
-
buff.setbyte(current_len, byte)
|
17274
|
-
current_len += 1
|
17275
|
-
end
|
17276
|
-
end
|
17277
|
-
end
|
17914
|
+
result
|
17915
|
+
end
|
17278
17916
|
|
17279
|
-
|
17280
|
-
|
17281
|
-
buff << 0x28
|
17917
|
+
def as_json(options = {})
|
17918
|
+
result = {}
|
17282
17919
|
|
17283
|
-
|
17284
|
-
elsif val == false
|
17285
|
-
# Default value, encode nothing
|
17286
|
-
else
|
17287
|
-
raise "bool values should be true or false"
|
17288
|
-
end
|
17920
|
+
resolved_target = self.target
|
17289
17921
|
|
17290
|
-
|
17291
|
-
|
17922
|
+
result["abilityId"] = @ability_id if !options[:compact] || has_ability_id?
|
17923
|
+
result["targetWorldSpacePos"] = (
|
17924
|
+
if @target_world_space_pos.nil?
|
17925
|
+
{}
|
17926
|
+
else
|
17927
|
+
@target_world_space_pos.as_json(options)
|
17928
|
+
end
|
17929
|
+
) if resolved_target == :"target_world_space_pos"
|
17930
|
+
result["targetUnitTag"] = @target_unit_tag if resolved_target ==
|
17931
|
+
:"target_unit_tag"
|
17932
|
+
tmp_unit_tags = @unit_tags
|
17933
|
+
|
17934
|
+
result["unitTags"] = tmp_unit_tags if !options[:compact] ||
|
17935
|
+
tmp_unit_tags.any?
|
17936
|
+
|
17937
|
+
result["queueCommand"] = @queue_command if !options[:compact] ||
|
17938
|
+
has_queue_command?
|
17292
17939
|
|
17293
|
-
def to_h
|
17294
|
-
result = {}
|
17295
|
-
send("target").tap { |f| result[f.to_sym] = send(f) if f }
|
17296
|
-
result["ability_id".to_sym] = @ability_id
|
17297
|
-
result["unit_tags".to_sym] = @unit_tags
|
17298
|
-
result["queue_command".to_sym] = @queue_command
|
17299
17940
|
result
|
17300
17941
|
end
|
17942
|
+
|
17943
|
+
def to_json(as_json_options = {})
|
17944
|
+
require "json"
|
17945
|
+
JSON.dump(as_json(as_json_options))
|
17946
|
+
end
|
17301
17947
|
end
|
17302
17948
|
class ActionRawCameraMove
|
17303
17949
|
def self.decode(buff)
|
@@ -17404,20 +18050,39 @@ module Api
|
|
17404
18050
|
# unexpected, so discard it and continue.
|
17405
18051
|
if !found
|
17406
18052
|
wire_type = tag & 0x7
|
18053
|
+
|
18054
|
+
unknown_bytes = +"".b
|
18055
|
+
val = tag
|
18056
|
+
loop do
|
18057
|
+
byte = val & 0x7F
|
18058
|
+
|
18059
|
+
val >>= 7
|
18060
|
+
# This drops the top bits,
|
18061
|
+
# Otherwise, with a signed right shift,
|
18062
|
+
# we get infinity one bits at the top
|
18063
|
+
val &= (1 << 57) - 1
|
18064
|
+
|
18065
|
+
byte |= 0x80 if val != 0
|
18066
|
+
unknown_bytes << byte
|
18067
|
+
break if val == 0
|
18068
|
+
end
|
18069
|
+
|
17407
18070
|
case wire_type
|
17408
18071
|
when 0
|
17409
18072
|
i = 0
|
17410
18073
|
while true
|
17411
18074
|
newbyte = buff.getbyte(index)
|
17412
18075
|
index += 1
|
17413
|
-
break if newbyte.nil?
|
18076
|
+
break if newbyte.nil?
|
18077
|
+
unknown_bytes << newbyte
|
18078
|
+
break if newbyte < 0x80
|
17414
18079
|
i += 1
|
17415
18080
|
break if i > 9
|
17416
18081
|
end
|
17417
18082
|
when 1
|
18083
|
+
unknown_bytes << buff.byteslice(index, 8)
|
17418
18084
|
index += 8
|
17419
18085
|
when 2
|
17420
|
-
## PULL_BYTES
|
17421
18086
|
value =
|
17422
18087
|
if (byte0 = buff.getbyte(index)) < 0x80
|
17423
18088
|
index += 1
|
@@ -17473,15 +18138,30 @@ module Api
|
|
17473
18138
|
raise "integer decoding error"
|
17474
18139
|
end
|
17475
18140
|
|
17476
|
-
|
17477
|
-
|
18141
|
+
val = value
|
18142
|
+
loop do
|
18143
|
+
byte = val & 0x7F
|
18144
|
+
|
18145
|
+
val >>= 7
|
18146
|
+
# This drops the top bits,
|
18147
|
+
# Otherwise, with a signed right shift,
|
18148
|
+
# we get infinity one bits at the top
|
18149
|
+
val &= (1 << 57) - 1
|
18150
|
+
|
18151
|
+
byte |= 0x80 if val != 0
|
18152
|
+
unknown_bytes << byte
|
18153
|
+
break if val == 0
|
18154
|
+
end
|
17478
18155
|
|
17479
|
-
|
18156
|
+
unknown_bytes << buff.byteslice(index, value)
|
18157
|
+
index += value
|
17480
18158
|
when 5
|
18159
|
+
unknown_bytes << buff.byteslice(index, 4)
|
17481
18160
|
index += 4
|
17482
18161
|
else
|
17483
18162
|
raise "unknown wire type #{wire_type}"
|
17484
18163
|
end
|
18164
|
+
(@_unknown_fields ||= +"".b) << unknown_bytes
|
17485
18165
|
return self if index >= len
|
17486
18166
|
## PULL_UINT64
|
17487
18167
|
tag =
|
@@ -17702,15 +18382,36 @@ module Api
|
|
17702
18382
|
|
17703
18383
|
buff
|
17704
18384
|
end
|
17705
|
-
|
18385
|
+
buff << @_unknown_fields if @_unknown_fields
|
17706
18386
|
buff
|
17707
18387
|
end
|
17708
18388
|
|
17709
18389
|
def to_h
|
17710
18390
|
result = {}
|
17711
|
-
|
18391
|
+
|
18392
|
+
result[:"center_world_space"] = @center_world_space.to_h
|
18393
|
+
|
18394
|
+
result
|
18395
|
+
end
|
18396
|
+
|
18397
|
+
def as_json(options = {})
|
18398
|
+
result = {}
|
18399
|
+
|
18400
|
+
result["centerWorldSpace"] = (
|
18401
|
+
if @center_world_space.nil?
|
18402
|
+
{}
|
18403
|
+
else
|
18404
|
+
@center_world_space.as_json(options)
|
18405
|
+
end
|
18406
|
+
) if !options[:compact] || has_center_world_space?
|
18407
|
+
|
17712
18408
|
result
|
17713
18409
|
end
|
18410
|
+
|
18411
|
+
def to_json(as_json_options = {})
|
18412
|
+
require "json"
|
18413
|
+
JSON.dump(as_json(as_json_options))
|
18414
|
+
end
|
17714
18415
|
end
|
17715
18416
|
class ActionRawToggleAutocast
|
17716
18417
|
def self.decode(buff)
|
@@ -17848,20 +18549,39 @@ module Api
|
|
17848
18549
|
# unexpected, so discard it and continue.
|
17849
18550
|
if !found
|
17850
18551
|
wire_type = tag & 0x7
|
18552
|
+
|
18553
|
+
unknown_bytes = +"".b
|
18554
|
+
val = tag
|
18555
|
+
loop do
|
18556
|
+
byte = val & 0x7F
|
18557
|
+
|
18558
|
+
val >>= 7
|
18559
|
+
# This drops the top bits,
|
18560
|
+
# Otherwise, with a signed right shift,
|
18561
|
+
# we get infinity one bits at the top
|
18562
|
+
val &= (1 << 57) - 1
|
18563
|
+
|
18564
|
+
byte |= 0x80 if val != 0
|
18565
|
+
unknown_bytes << byte
|
18566
|
+
break if val == 0
|
18567
|
+
end
|
18568
|
+
|
17851
18569
|
case wire_type
|
17852
18570
|
when 0
|
17853
18571
|
i = 0
|
17854
18572
|
while true
|
17855
18573
|
newbyte = buff.getbyte(index)
|
17856
18574
|
index += 1
|
17857
|
-
break if newbyte.nil?
|
18575
|
+
break if newbyte.nil?
|
18576
|
+
unknown_bytes << newbyte
|
18577
|
+
break if newbyte < 0x80
|
17858
18578
|
i += 1
|
17859
18579
|
break if i > 9
|
17860
18580
|
end
|
17861
18581
|
when 1
|
18582
|
+
unknown_bytes << buff.byteslice(index, 8)
|
17862
18583
|
index += 8
|
17863
18584
|
when 2
|
17864
|
-
## PULL_BYTES
|
17865
18585
|
value =
|
17866
18586
|
if (byte0 = buff.getbyte(index)) < 0x80
|
17867
18587
|
index += 1
|
@@ -17917,15 +18637,30 @@ module Api
|
|
17917
18637
|
raise "integer decoding error"
|
17918
18638
|
end
|
17919
18639
|
|
17920
|
-
|
17921
|
-
|
18640
|
+
val = value
|
18641
|
+
loop do
|
18642
|
+
byte = val & 0x7F
|
18643
|
+
|
18644
|
+
val >>= 7
|
18645
|
+
# This drops the top bits,
|
18646
|
+
# Otherwise, with a signed right shift,
|
18647
|
+
# we get infinity one bits at the top
|
18648
|
+
val &= (1 << 57) - 1
|
18649
|
+
|
18650
|
+
byte |= 0x80 if val != 0
|
18651
|
+
unknown_bytes << byte
|
18652
|
+
break if val == 0
|
18653
|
+
end
|
17922
18654
|
|
17923
|
-
|
18655
|
+
unknown_bytes << buff.byteslice(index, value)
|
18656
|
+
index += value
|
17924
18657
|
when 5
|
18658
|
+
unknown_bytes << buff.byteslice(index, 4)
|
17925
18659
|
index += 4
|
17926
18660
|
else
|
17927
18661
|
raise "unknown wire type #{wire_type}"
|
17928
18662
|
end
|
18663
|
+
(@_unknown_fields ||= +"".b) << unknown_bytes
|
17929
18664
|
return self if index >= len
|
17930
18665
|
## PULL_UINT64
|
17931
18666
|
tag =
|
@@ -18101,64 +18836,11 @@ module Api
|
|
18101
18836
|
|
18102
18837
|
## END PULL_UINT64
|
18103
18838
|
end
|
18104
|
-
if tag ==
|
18839
|
+
if tag == 0x10
|
18105
18840
|
found = true
|
18106
|
-
##
|
18107
|
-
value =
|
18108
|
-
if (byte0 = buff.getbyte(index)) < 0x80
|
18109
|
-
index += 1
|
18110
|
-
byte0
|
18111
|
-
elsif (byte1 = buff.getbyte(index + 1)) < 0x80
|
18112
|
-
index += 2
|
18113
|
-
(byte1 << 7) | (byte0 & 0x7F)
|
18114
|
-
elsif (byte2 = buff.getbyte(index + 2)) < 0x80
|
18115
|
-
index += 3
|
18116
|
-
(byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
18117
|
-
elsif (byte3 = buff.getbyte(index + 3)) < 0x80
|
18118
|
-
index += 4
|
18119
|
-
(byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
18120
|
-
(byte0 & 0x7F)
|
18121
|
-
elsif (byte4 = buff.getbyte(index + 4)) < 0x80
|
18122
|
-
index += 5
|
18123
|
-
(byte4 << 28) | ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
18124
|
-
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
18125
|
-
elsif (byte5 = buff.getbyte(index + 5)) < 0x80
|
18126
|
-
index += 6
|
18127
|
-
(byte5 << 35) | ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
18128
|
-
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
18129
|
-
elsif (byte6 = buff.getbyte(index + 6)) < 0x80
|
18130
|
-
index += 7
|
18131
|
-
(byte6 << 42) | ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
18132
|
-
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
18133
|
-
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
18134
|
-
elsif (byte7 = buff.getbyte(index + 7)) < 0x80
|
18135
|
-
index += 8
|
18136
|
-
(byte7 << 49) | ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
|
18137
|
-
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
18138
|
-
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
18139
|
-
elsif (byte8 = buff.getbyte(index + 8)) < 0x80
|
18140
|
-
index += 9
|
18141
|
-
(byte8 << 56) | ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
|
18142
|
-
((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
18143
|
-
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
18144
|
-
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
18145
|
-
elsif (byte9 = buff.getbyte(index + 9)) < 0x80
|
18146
|
-
index += 10
|
18147
|
-
|
18148
|
-
(byte9 << 63) | ((byte8 & 0x7F) << 56) | ((byte7 & 0x7F) << 49) |
|
18149
|
-
((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
|
18150
|
-
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
18151
|
-
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
18152
|
-
else
|
18153
|
-
raise "integer decoding error"
|
18154
|
-
end
|
18155
|
-
|
18156
|
-
## END PULL_UINT64
|
18157
|
-
|
18158
|
-
goal = index + value
|
18841
|
+
## DECODE REPEATED
|
18159
18842
|
list = @unit_tags
|
18160
18843
|
while true
|
18161
|
-
break if index >= goal
|
18162
18844
|
## PULL_UINT64
|
18163
18845
|
list << if (byte0 = buff.getbyte(index)) < 0x80
|
18164
18846
|
index += 1
|
@@ -18209,60 +18891,71 @@ module Api
|
|
18209
18891
|
end
|
18210
18892
|
|
18211
18893
|
## END PULL_UINT64
|
18212
|
-
end
|
18213
18894
|
|
18214
|
-
|
18215
|
-
|
18216
|
-
|
18217
|
-
|
18218
|
-
|
18219
|
-
|
18220
|
-
|
18221
|
-
|
18222
|
-
|
18223
|
-
|
18224
|
-
|
18225
|
-
|
18226
|
-
|
18227
|
-
|
18228
|
-
|
18229
|
-
|
18230
|
-
|
18231
|
-
|
18232
|
-
|
18233
|
-
|
18234
|
-
|
18235
|
-
index
|
18236
|
-
|
18237
|
-
(
|
18238
|
-
|
18239
|
-
|
18240
|
-
(byte6
|
18241
|
-
|
18242
|
-
(
|
18243
|
-
|
18244
|
-
|
18245
|
-
|
18246
|
-
|
18247
|
-
|
18248
|
-
|
18249
|
-
|
18250
|
-
|
18251
|
-
|
18252
|
-
|
18253
|
-
|
18254
|
-
|
18255
|
-
|
18895
|
+
return self if index >= len
|
18896
|
+
## PULL_UINT64
|
18897
|
+
tag =
|
18898
|
+
if (byte0 = buff.getbyte(index)) < 0x80
|
18899
|
+
index += 1
|
18900
|
+
byte0
|
18901
|
+
elsif (byte1 = buff.getbyte(index + 1)) < 0x80
|
18902
|
+
index += 2
|
18903
|
+
(byte1 << 7) | (byte0 & 0x7F)
|
18904
|
+
elsif (byte2 = buff.getbyte(index + 2)) < 0x80
|
18905
|
+
index += 3
|
18906
|
+
(byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
18907
|
+
elsif (byte3 = buff.getbyte(index + 3)) < 0x80
|
18908
|
+
index += 4
|
18909
|
+
(byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
18910
|
+
(byte0 & 0x7F)
|
18911
|
+
elsif (byte4 = buff.getbyte(index + 4)) < 0x80
|
18912
|
+
index += 5
|
18913
|
+
(byte4 << 28) | ((byte3 & 0x7F) << 21) |
|
18914
|
+
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
18915
|
+
(byte0 & 0x7F)
|
18916
|
+
elsif (byte5 = buff.getbyte(index + 5)) < 0x80
|
18917
|
+
index += 6
|
18918
|
+
(byte5 << 35) | ((byte4 & 0x7F) << 28) |
|
18919
|
+
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
18920
|
+
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
18921
|
+
elsif (byte6 = buff.getbyte(index + 6)) < 0x80
|
18922
|
+
index += 7
|
18923
|
+
(byte6 << 42) | ((byte5 & 0x7F) << 35) |
|
18924
|
+
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
18925
|
+
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
18926
|
+
(byte0 & 0x7F)
|
18927
|
+
elsif (byte7 = buff.getbyte(index + 7)) < 0x80
|
18928
|
+
index += 8
|
18929
|
+
(byte7 << 49) | ((byte6 & 0x7F) << 42) |
|
18930
|
+
((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
18931
|
+
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
18932
|
+
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
18933
|
+
elsif (byte8 = buff.getbyte(index + 8)) < 0x80
|
18934
|
+
index += 9
|
18935
|
+
(byte8 << 56) | ((byte7 & 0x7F) << 49) |
|
18936
|
+
((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
|
18937
|
+
((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
|
18938
|
+
((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
|
18939
|
+
(byte0 & 0x7F)
|
18940
|
+
elsif (byte9 = buff.getbyte(index + 9)) < 0x80
|
18941
|
+
index += 10
|
18256
18942
|
|
18257
|
-
|
18258
|
-
|
18259
|
-
|
18260
|
-
|
18261
|
-
|
18262
|
-
|
18263
|
-
|
18943
|
+
(byte9 << 63) | ((byte8 & 0x7F) << 56) |
|
18944
|
+
((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
|
18945
|
+
((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
|
18946
|
+
((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
|
18947
|
+
((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
|
18948
|
+
else
|
18949
|
+
raise "integer decoding error"
|
18950
|
+
end
|
18264
18951
|
|
18265
|
-
|
18952
|
+
## END PULL_UINT64
|
18953
|
+
|
18954
|
+
break unless tag == 0x10
|
18955
|
+
end
|
18956
|
+
## END DECODE REPEATED
|
18957
|
+
|
18958
|
+
return self if index >= len
|
18266
18959
|
end
|
18267
18960
|
|
18268
18961
|
return self if index >= len
|
@@ -18270,10 +18963,10 @@ module Api
|
|
18270
18963
|
end
|
18271
18964
|
def _encode(buff)
|
18272
18965
|
val = @ability_id
|
18273
|
-
if
|
18966
|
+
if has_ability_id?
|
18274
18967
|
buff << 0x08
|
18275
18968
|
|
18276
|
-
|
18969
|
+
loop do
|
18277
18970
|
byte = val & 0x7F
|
18278
18971
|
|
18279
18972
|
val >>= 7
|
@@ -18284,75 +18977,55 @@ module Api
|
|
18284
18977
|
|
18285
18978
|
byte |= 0x80 if val != 0
|
18286
18979
|
buff << byte
|
18980
|
+
break if val == 0
|
18287
18981
|
end
|
18288
18982
|
end
|
18289
18983
|
|
18290
18984
|
list = @unit_tags
|
18291
18985
|
if list.size > 0
|
18292
|
-
buff << 0x12
|
18293
|
-
|
18294
|
-
# Save the buffer size before appending the repeated bytes
|
18295
|
-
current_len = buff.bytesize
|
18296
|
-
|
18297
|
-
# Write a single dummy byte to later store encoded length
|
18298
|
-
buff << 42 # "*"
|
18299
|
-
|
18300
|
-
# write each item
|
18301
18986
|
list.each do |item|
|
18302
18987
|
val = item
|
18303
18988
|
if val != 0
|
18304
|
-
|
18989
|
+
buff << 0x10
|
18990
|
+
|
18991
|
+
loop do
|
18305
18992
|
byte = val & 0x7F
|
18306
18993
|
val >>= 7
|
18307
18994
|
byte |= 0x80 if val > 0
|
18308
18995
|
buff << byte
|
18996
|
+
break if val == 0
|
18309
18997
|
end
|
18310
18998
|
end
|
18311
18999
|
end
|
19000
|
+
end
|
19001
|
+
buff << @_unknown_fields if @_unknown_fields
|
19002
|
+
buff
|
19003
|
+
end
|
18312
19004
|
|
18313
|
-
|
18314
|
-
|
19005
|
+
def to_h
|
19006
|
+
result = {}
|
18315
19007
|
|
18316
|
-
|
18317
|
-
|
18318
|
-
submessage_size >>= 7
|
18319
|
-
byte |= 0x80 if submessage_size > 0
|
18320
|
-
buff.setbyte(current_len, byte)
|
19008
|
+
result[:"ability_id"] = @ability_id
|
19009
|
+
result[:"unit_tags"] = @unit_tags
|
18321
19010
|
|
18322
|
-
|
18323
|
-
|
18324
|
-
current_len += 1
|
19011
|
+
result
|
19012
|
+
end
|
18325
19013
|
|
18326
|
-
|
18327
|
-
|
18328
|
-
remaining_size = submessage_size
|
18329
|
-
while remaining_size != 0
|
18330
|
-
remaining_size >>= 7
|
18331
|
-
encoded_int_len += 1
|
18332
|
-
end
|
19014
|
+
def as_json(options = {})
|
19015
|
+
result = {}
|
18333
19016
|
|
18334
|
-
|
18335
|
-
|
19017
|
+
result["abilityId"] = @ability_id if !options[:compact] || has_ability_id?
|
19018
|
+
tmp_unit_tags = @unit_tags
|
18336
19019
|
|
18337
|
-
|
18338
|
-
|
18339
|
-
byte = submessage_size & 0x7F
|
18340
|
-
submessage_size >>= 7
|
18341
|
-
byte |= 0x80 if submessage_size > 0
|
18342
|
-
buff.setbyte(current_len, byte)
|
18343
|
-
current_len += 1
|
18344
|
-
end
|
18345
|
-
end
|
18346
|
-
end
|
19020
|
+
result["unitTags"] = tmp_unit_tags if !options[:compact] ||
|
19021
|
+
tmp_unit_tags.any?
|
18347
19022
|
|
18348
|
-
|
19023
|
+
result
|
18349
19024
|
end
|
18350
19025
|
|
18351
|
-
def
|
18352
|
-
|
18353
|
-
|
18354
|
-
result["unit_tags".to_sym] = @unit_tags
|
18355
|
-
result
|
19026
|
+
def to_json(as_json_options = {})
|
19027
|
+
require "json"
|
19028
|
+
JSON.dump(as_json(as_json_options))
|
18356
19029
|
end
|
18357
19030
|
end
|
18358
19031
|
end
|