sc2ai 0.4.2 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (44) hide show
  1. checksums.yaml +4 -4
  2. data/data/sc2ai/protocol/data.proto +2 -2
  3. data/data/sc2ai/protocol/debug.proto +1 -1
  4. data/data/sc2ai/protocol/raw.proto +6 -6
  5. data/data/sc2ai/protocol/sc2api.proto +1 -1
  6. data/data/sc2ai/protocol/ui.proto +1 -1
  7. data/{lib/docker_build → docker_build}/Dockerfile.ruby +2 -2
  8. data/lib/sc2ai/cli/ladderzip.rb +1 -1
  9. data/lib/sc2ai/local_play/client.rb +1 -1
  10. data/lib/sc2ai/local_play/match.rb +1 -0
  11. data/lib/sc2ai/overrides/async/process/child.rb +2 -1
  12. data/lib/sc2ai/paths.rb +0 -1
  13. data/lib/sc2ai/player/debug.rb +3 -3
  14. data/lib/sc2ai/player.rb +9 -0
  15. data/lib/sc2ai/protocol/common_pb.rb +460 -105
  16. data/lib/sc2ai/protocol/data_pb.rb +833 -482
  17. data/lib/sc2ai/protocol/debug_pb.rb +1112 -401
  18. data/lib/sc2ai/protocol/error_pb.rb +430 -862
  19. data/lib/sc2ai/protocol/extensions/action.rb +1 -1
  20. data/lib/sc2ai/protocol/extensions/color.rb +1 -1
  21. data/lib/sc2ai/protocol/extensions/point.rb +1 -1
  22. data/lib/sc2ai/protocol/extensions/point_2_d.rb +1 -1
  23. data/lib/sc2ai/protocol/extensions/point_distance.rb +4 -4
  24. data/lib/sc2ai/protocol/extensions/position.rb +20 -0
  25. data/lib/sc2ai/protocol/extensions/power_source.rb +1 -1
  26. data/lib/sc2ai/protocol/extensions/unit.rb +1 -1
  27. data/lib/sc2ai/protocol/extensions/unit_type_data.rb +1 -1
  28. data/lib/sc2ai/protocol/query_pb.rb +558 -88
  29. data/lib/sc2ai/protocol/raw_pb.rb +1829 -1156
  30. data/lib/sc2ai/protocol/sc2api_pb.rb +5233 -1463
  31. data/lib/sc2ai/protocol/score_pb.rb +444 -103
  32. data/lib/sc2ai/protocol/spatial_pb.rb +935 -145
  33. data/lib/sc2ai/protocol/ui_pb.rb +1432 -435
  34. data/lib/sc2ai/version.rb +1 -1
  35. data/lib/templates/new/api/data.proto +2 -2
  36. data/lib/templates/new/api/debug.proto +1 -1
  37. data/lib/templates/new/api/raw.proto +6 -6
  38. data/lib/templates/new/api/sc2api.proto +1 -1
  39. data/lib/templates/new/api/ui.proto +1 -1
  40. data/lib/templates/new/run_example_match.rb.tt +1 -1
  41. data/sig/sc2ai.rbs +1361 -23
  42. metadata +7 -7
  43. /data/{lib/docker_build → docker_build}/docker-compose-base-image.yml +0 -0
  44. /data/{lib/docker_build → docker_build}/docker-compose-ladderzip.yml +0 -0
@@ -11,31 +11,19 @@ module Api
11
11
  PLACEHOLDER = 4
12
12
 
13
13
  def self.lookup(val)
14
- if val == 0
15
- :ENUM_DISPLAY_TYPE_UNSET
16
- elsif val == 1
17
- :VISIBLE
18
- elsif val == 2
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
- 0
30
- elsif val == :VISIBLE
31
- 1
32
- elsif val == :SNAPSHOT
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
- :ENUM_ALLIANCE_UNSET
51
- elsif val == 1
52
- :SELF
53
- elsif val == 2
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
- 0
65
- elsif val == :SELF
66
- 1
67
- elsif val == :ALLY
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
- :CLOAKED_UNKNOWN
86
- elsif val == 1
87
- :CLOAKED
88
- elsif val == 2
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
- 0
100
- elsif val == :CLOAKED
101
- 1
102
- elsif val == :CLOAKED_DETECTED
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? || newbyte < 0x80
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
- buff.byteslice(index, value)
379
- index += value
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
- ## END PULL_BYTES
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
- result["map_size".to_sym] = @map_size.to_h
1447
- result["pathing_grid".to_sym] = @pathing_grid.to_h
1448
- result["terrain_height".to_sym] = @terrain_height.to_h
1449
- result["placement_grid".to_sym] = @placement_grid.to_h
1450
- result["playable_area".to_sym] = @playable_area.to_h
1451
- result["start_locations".to_sym] = @start_locations
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? || newbyte < 0x80
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
- buff.byteslice(index, value)
1702
- index += value
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
- ## END PULL_BYTES
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
- result["player".to_sym] = @player.to_h
2826
- result["units".to_sym] = @units
2827
- result["map_state".to_sym] = @map_state.to_h
2828
- result["event".to_sym] = @event.to_h
2829
- result["effects".to_sym] = @effects
2830
- result["radar".to_sym] = @radar
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? || newbyte < 0x80
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
- buff.byteslice(index, value)
3028
- index += value
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
- ## END PULL_BYTES
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 val != 0
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
- result["pos".to_sym] = @pos.to_h
3327
- result["radius".to_sym] = @radius
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? || newbyte < 0x80
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
- buff.byteslice(index, value)
3553
- index += value
3750
+ val = value
3751
+ loop do
3752
+ byte = val & 0x7F
3554
3753
 
3555
- ## END PULL_BYTES
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 val != 0
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 val != 0
4168
+ if has_tag?
3956
4169
  buff << 0x18
3957
4170
 
3958
- while val != 0
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
- result["pos".to_sym] = @pos.to_h
3972
- result["radius".to_sym] = @radius
3973
- result["tag".to_sym] = @tag
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? || newbyte < 0x80
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
- buff.byteslice(index, value)
4183
- index += value
4434
+ val = value
4435
+ loop do
4436
+ byte = val & 0x7F
4184
4437
 
4185
- ## END PULL_BYTES
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 == 0x1a
4762
+ if tag == 0x18
4496
4763
  found = true
4497
- ## PULL_UINT64
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
- while val != 0
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
- # Calculate the submessage's size
4788
- submessage_size = buff.bytesize - current_len - 1
5010
+ def to_h
5011
+ result = {}
4789
5012
 
4790
- # Hope the size fits in one byte
4791
- byte = submessage_size & 0x7F
4792
- submessage_size >>= 7
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
- # If the sub message was bigger
4797
- if submessage_size > 0
4798
- current_len += 1
5017
+ result
5018
+ end
4799
5019
 
4800
- # compute how much we need to shift
4801
- encoded_int_len = 0
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
- # Make space in the string with dummy bytes
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
- # Overwrite the dummy bytes with the encoded length
4812
- while submessage_size != 0
4813
- byte = submessage_size & 0x7F
4814
- submessage_size >>= 7
4815
- byte |= 0x80 if submessage_size > 0
4816
- buff.setbyte(current_len, byte)
4817
- current_len += 1
4818
- end
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
- end
5034
+ ) if !options[:compact] || has_camera?
5035
+ tmp_upgrade_ids = @upgrade_ids
4821
5036
 
4822
- buff
4823
- end
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? || newbyte < 0x80
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
- buff.byteslice(index, value)
5090
- index += value
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
- ## END PULL_BYTES
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 val != 0
5795
+ if has_ability_id?
5547
5796
  buff << 0x08
5548
5797
 
5549
- while val != 0
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
- while val != 0
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 val != 0
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
- send("target").tap { |f| result[f.to_sym] = send(f) if f }
5630
- result["ability_id".to_sym] = @ability_id
5631
- result["progress".to_sym] = @progress
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? || newbyte < 0x80
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
- buff.byteslice(index, value)
5970
- index += value
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
- ## END PULL_BYTES
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 val != 0
6922
+ if has_tag?
6604
6923
  buff << 0x08
6605
6924
 
6606
- while val != 0
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 val != 0
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 val != 0
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 val != 0
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 val != 0
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 val != 0
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 val != 0
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 val != 0
6977
+ if has_unit_type?
6658
6978
  buff << 0x30
6659
6979
 
6660
- while val != 0
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
- result["tag".to_sym] = @tag
6674
- result["health".to_sym] = @health
6675
- result["health_max".to_sym] = @health_max
6676
- result["shield".to_sym] = @shield
6677
- result["shield_max".to_sym] = @shield_max
6678
- result["energy".to_sym] = @energy
6679
- result["energy_max".to_sym] = @energy_max
6680
- result["unit_type".to_sym] = @unit_type
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? || newbyte < 0x80
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
- buff.byteslice(index, value)
6887
- index += value
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
- ## END PULL_BYTES
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 val != 0
7602
+ if has_tag?
7226
7603
  buff << 0x10
7227
7604
 
7228
- while val != 0
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
- result["point".to_sym] = @point.to_h
7242
- result["tag".to_sym] = @tag
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? || newbyte < 0x80
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
- buff.byteslice(index, value)
8400
- index += value
8829
+ val = value
8830
+ loop do
8831
+ byte = val & 0x7F
8401
8832
 
8402
- ## END PULL_BYTES
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 == 0xda
9890
+ if tag == 0xd8
9446
9891
  found = true
9447
- ## PULL_UINT64
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
- return self if index >= len
9556
- ## PULL_UINT64
9557
- tag =
9558
- if (byte0 = buff.getbyte(index)) < 0x80
9559
- index += 1
9560
- byte0
9561
- elsif (byte1 = buff.getbyte(index + 1)) < 0x80
9562
- index += 2
9563
- (byte1 << 7) | (byte0 & 0x7F)
9564
- elsif (byte2 = buff.getbyte(index + 2)) < 0x80
9565
- index += 3
9566
- (byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
9567
- elsif (byte3 = buff.getbyte(index + 3)) < 0x80
9568
- index += 4
9569
- (byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
9570
- (byte0 & 0x7F)
9571
- elsif (byte4 = buff.getbyte(index + 4)) < 0x80
9572
- index += 5
9573
- (byte4 << 28) | ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
9574
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
9575
- elsif (byte5 = buff.getbyte(index + 5)) < 0x80
9576
- index += 6
9577
- (byte5 << 35) | ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
9578
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
9579
- elsif (byte6 = buff.getbyte(index + 6)) < 0x80
9580
- index += 7
9581
- (byte6 << 42) | ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
9582
- ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
9583
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
9584
- elsif (byte7 = buff.getbyte(index + 7)) < 0x80
9585
- index += 8
9586
- (byte7 << 49) | ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
9587
- ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
9588
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
9589
- elsif (byte8 = buff.getbyte(index + 8)) < 0x80
9590
- index += 9
9591
- (byte8 << 56) | ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
9592
- ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
9593
- ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
9594
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
9595
- elsif (byte9 = buff.getbyte(index + 9)) < 0x80
9596
- index += 10
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
- (byte9 << 63) | ((byte8 & 0x7F) << 56) | ((byte7 & 0x7F) << 49) |
9599
- ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
9600
- ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
9601
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
9602
- else
9603
- raise "integer decoding error"
9604
- end
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
- ## END PULL_UINT64
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 val != 0
12971
+ if has_display_type?
12569
12972
  buff << 0x08
12570
12973
 
12571
- while val != 0
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 val != 0
12990
+ if has_alliance?
12587
12991
  buff << 0x10
12588
12992
 
12589
- while val != 0
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 val != 0
13009
+ if has_tag?
12605
13010
  buff << 0x18
12606
13011
 
12607
- while val != 0
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 val != 0
13022
+ if has_unit_type?
12617
13023
  buff << 0x20
12618
13024
 
12619
- while val != 0
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 val != 0
13035
+ if has_owner?
12629
13036
  buff << 0x28
12630
13037
 
12631
- while val != 0
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 val != 0
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 val != 0
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 val != 0
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 val != 0
13123
+ if has_cloak?
12716
13124
  buff << 0x50
12717
13125
 
12718
- while val != 0
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
- while val != 0
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 val != 0
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 val != 0
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
- val = @is_selected
12808
- if val == true
13176
+ if has_is_selected?
13177
+ val = @is_selected
12809
13178
  buff << 0x58
12810
13179
 
12811
- buff << 1
12812
- elsif val == false
12813
- # Default value, encode nothing
12814
- else
12815
- raise "bool values should be true or false"
13180
+ if val == true
13181
+ buff << 1
13182
+ elsif val == false
13183
+ buff << 0
13184
+ end
12816
13185
  end
12817
13186
 
12818
- val = @is_on_screen
12819
- if val == true
13187
+ if has_is_on_screen?
13188
+ val = @is_on_screen
12820
13189
  buff << 0x60
12821
13190
 
12822
- buff << 1
12823
- elsif val == false
12824
- # Default value, encode nothing
12825
- else
12826
- raise "bool values should be true or false"
13191
+ if val == true
13192
+ buff << 1
13193
+ elsif val == false
13194
+ buff << 0
13195
+ end
12827
13196
  end
12828
13197
 
12829
- val = @is_blip
12830
- if val == true
13198
+ if has_is_blip?
13199
+ val = @is_blip
12831
13200
  buff << 0x68
12832
13201
 
12833
- buff << 1
12834
- elsif val == false
12835
- # Default value, encode nothing
12836
- else
12837
- raise "bool values should be true or false"
13202
+ if val == true
13203
+ buff << 1
13204
+ elsif val == false
13205
+ buff << 0
13206
+ end
12838
13207
  end
12839
13208
 
12840
- val = @is_powered
12841
- if val == true
13209
+ if has_is_powered?
13210
+ val = @is_powered
12842
13211
  buff << 0x98
12843
13212
  buff << 0x02
12844
13213
 
12845
- buff << 1
12846
- elsif val == false
12847
- # Default value, encode nothing
12848
- else
12849
- raise "bool values should be true or false"
13214
+ if val == true
13215
+ buff << 1
13216
+ elsif val == false
13217
+ buff << 0
13218
+ end
12850
13219
  end
12851
13220
 
12852
- val = @is_active
12853
- if val == true
13221
+ if has_is_active?
13222
+ val = @is_active
12854
13223
  buff << 0xb8
12855
13224
  buff << 0x02
12856
13225
 
12857
- buff << 1
12858
- elsif val == false
12859
- # Default value, encode nothing
12860
- else
12861
- raise "bool values should be true or false"
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 val != 0
13234
+ if has_attack_upgrade_level?
12866
13235
  buff << 0xc0
12867
13236
  buff << 0x02
12868
13237
 
12869
- while val != 0
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 val != 0
13254
+ if has_armor_upgrade_level?
12885
13255
  buff << 0xc8
12886
13256
  buff << 0x02
12887
13257
 
12888
- while val != 0
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 val != 0
13274
+ if has_shield_upgrade_level?
12904
13275
  buff << 0xd0
12905
13276
  buff << 0x02
12906
13277
 
12907
- while val != 0
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 val != 0
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 val != 0
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 val != 0
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 val != 0
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 val != 0
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 val != 0
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 val != 0
13340
+ if has_mineral_contents?
12969
13341
  buff << 0x90
12970
13342
  buff << 0x01
12971
13343
 
12972
- while val != 0
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 val != 0
13360
+ if has_vespene_contents?
12988
13361
  buff << 0x98
12989
13362
  buff << 0x01
12990
13363
 
12991
- while val != 0
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
- val = @is_flying
13006
- if val == true
13379
+ if has_is_flying?
13380
+ val = @is_flying
13007
13381
  buff << 0xa0
13008
13382
  buff << 0x01
13009
13383
 
13010
- buff << 1
13011
- elsif val == false
13012
- # Default value, encode nothing
13013
- else
13014
- raise "bool values should be true or false"
13384
+ if val == true
13385
+ buff << 1
13386
+ elsif val == false
13387
+ buff << 0
13388
+ end
13015
13389
  end
13016
13390
 
13017
- val = @is_burrowed
13018
- if val == true
13391
+ if has_is_burrowed?
13392
+ val = @is_burrowed
13019
13393
  buff << 0xa8
13020
13394
  buff << 0x01
13021
13395
 
13022
- buff << 1
13023
- elsif val == false
13024
- # Default value, encode nothing
13025
- else
13026
- raise "bool values should be true or false"
13396
+ if val == true
13397
+ buff << 1
13398
+ elsif val == false
13399
+ buff << 0
13400
+ end
13027
13401
  end
13028
13402
 
13029
- val = @is_hallucination
13030
- if val == true
13403
+ if has_is_hallucination?
13404
+ val = @is_hallucination
13031
13405
  buff << 0xb0
13032
13406
  buff << 0x02
13033
13407
 
13034
- buff << 1
13035
- elsif val == false
13036
- # Default value, encode nothing
13037
- else
13038
- raise "bool values should be true or false"
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 val != 0
13470
+ if has_add_on_tag?
13097
13471
  buff << 0xb8
13098
13472
  buff << 0x01
13099
13473
 
13100
- while val != 0
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 val != 0
13538
+ if has_cargo_space_taken?
13164
13539
  buff << 0xc8
13165
13540
  buff << 0x01
13166
13541
 
13167
- while val != 0
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 val != 0
13558
+ if has_cargo_space_max?
13183
13559
  buff << 0xd0
13184
13560
  buff << 0x01
13185
13561
 
13186
- while val != 0
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 val != 0
13578
+ if has_assigned_harvesters?
13202
13579
  buff << 0xe0
13203
13580
  buff << 0x01
13204
13581
 
13205
- while val != 0
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 val != 0
13598
+ if has_ideal_harvesters?
13221
13599
  buff << 0xe8
13222
13600
  buff << 0x01
13223
13601
 
13224
- while val != 0
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 val != 0
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 val != 0
13626
+ if has_engaged_target_tag?
13248
13627
  buff << 0x90
13249
13628
  buff << 0x02
13250
13629
 
13251
- while val != 0
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 val != 0
13640
+ if has_buff_duration_remain?
13261
13641
  buff << 0xd8
13262
13642
  buff << 0x02
13263
13643
 
13264
- while val != 0
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 val != 0
13660
+ if has_buff_duration_max?
13280
13661
  buff << 0xe0
13281
13662
  buff << 0x02
13282
13663
 
13283
- while val != 0
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
- result["display_type".to_sym] = @display_type
13357
- result["alliance".to_sym] = @alliance
13358
- result["tag".to_sym] = @tag
13359
- result["unit_type".to_sym] = @unit_type
13360
- result["owner".to_sym] = @owner
13361
- result["pos".to_sym] = @pos.to_h
13362
- result["facing".to_sym] = @facing
13363
- result["radius".to_sym] = @radius
13364
- result["build_progress".to_sym] = @build_progress
13365
- result["cloak".to_sym] = @cloak
13366
- result["buff_ids".to_sym] = @buff_ids
13367
- result["detect_range".to_sym] = @detect_range
13368
- result["radar_range".to_sym] = @radar_range
13369
- result["is_selected".to_sym] = @is_selected
13370
- result["is_on_screen".to_sym] = @is_on_screen
13371
- result["is_blip".to_sym] = @is_blip
13372
- result["is_powered".to_sym] = @is_powered
13373
- result["is_active".to_sym] = @is_active
13374
- result["attack_upgrade_level".to_sym] = @attack_upgrade_level
13375
- result["armor_upgrade_level".to_sym] = @armor_upgrade_level
13376
- result["shield_upgrade_level".to_sym] = @shield_upgrade_level
13377
- result["health".to_sym] = @health
13378
- result["health_max".to_sym] = @health_max
13379
- result["shield".to_sym] = @shield
13380
- result["shield_max".to_sym] = @shield_max
13381
- result["energy".to_sym] = @energy
13382
- result["energy_max".to_sym] = @energy_max
13383
- result["mineral_contents".to_sym] = @mineral_contents
13384
- result["vespene_contents".to_sym] = @vespene_contents
13385
- result["is_flying".to_sym] = @is_flying
13386
- result["is_burrowed".to_sym] = @is_burrowed
13387
- result["is_hallucination".to_sym] = @is_hallucination
13388
- result["orders".to_sym] = @orders
13389
- result["add_on_tag".to_sym] = @add_on_tag
13390
- result["passengers".to_sym] = @passengers
13391
- result["cargo_space_taken".to_sym] = @cargo_space_taken
13392
- result["cargo_space_max".to_sym] = @cargo_space_max
13393
- result["assigned_harvesters".to_sym] = @assigned_harvesters
13394
- result["ideal_harvesters".to_sym] = @ideal_harvesters
13395
- result["weapon_cooldown".to_sym] = @weapon_cooldown
13396
- result["engaged_target_tag".to_sym] = @engaged_target_tag
13397
- result["buff_duration_remain".to_sym] = @buff_duration_remain
13398
- result["buff_duration_max".to_sym] = @buff_duration_max
13399
- result["rally_targets".to_sym] = @rally_targets
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? || newbyte < 0x80
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
- buff.byteslice(index, value)
13597
- index += value
14097
+ val = value
14098
+ loop do
14099
+ byte = val & 0x7F
13598
14100
 
13599
- ## END PULL_BYTES
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
- result["visibility".to_sym] = @visibility.to_h
13993
- result["creep".to_sym] = @creep.to_h
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? || newbyte < 0x80
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
- buff.byteslice(index, value)
14166
- index += value
14724
+ val = value
14725
+ loop do
14726
+ byte = val & 0x7F
14167
14727
 
14168
- ## END PULL_BYTES
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 == 0xa
14803
+ if tag == 0x8
14230
14804
  found = true
14231
- ## PULL_UINT64
14232
- value =
14233
- if (byte0 = buff.getbyte(index)) < 0x80
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
- ## END PULL_UINT64
14857
+ ## END PULL_UINT64
14282
14858
 
14283
- goal = index + value
14284
- list = @dead_units
14285
- while true
14286
- break if index >= goal
14859
+ return self if index >= len
14287
14860
  ## PULL_UINT64
14288
- list << if (byte0 = buff.getbyte(index)) < 0x80
14289
- index += 1
14290
- byte0
14291
- elsif (byte1 = buff.getbyte(index + 1)) < 0x80
14292
- index += 2
14293
- (byte1 << 7) | (byte0 & 0x7F)
14294
- elsif (byte2 = buff.getbyte(index + 2)) < 0x80
14295
- index += 3
14296
- (byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
14297
- elsif (byte3 = buff.getbyte(index + 3)) < 0x80
14298
- index += 4
14299
- (byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
14300
- (byte0 & 0x7F)
14301
- elsif (byte4 = buff.getbyte(index + 4)) < 0x80
14302
- index += 5
14303
- (byte4 << 28) | ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
14304
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
14305
- elsif (byte5 = buff.getbyte(index + 5)) < 0x80
14306
- index += 6
14307
- (byte5 << 35) | ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
14308
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
14309
- elsif (byte6 = buff.getbyte(index + 6)) < 0x80
14310
- index += 7
14311
- (byte6 << 42) | ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
14312
- ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
14313
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
14314
- elsif (byte7 = buff.getbyte(index + 7)) < 0x80
14315
- index += 8
14316
- (byte7 << 49) | ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
14317
- ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
14318
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
14319
- elsif (byte8 = buff.getbyte(index + 8)) < 0x80
14320
- index += 9
14321
- (byte8 << 56) | ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
14322
- ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
14323
- ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
14324
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
14325
- elsif (byte9 = buff.getbyte(index + 9)) < 0x80
14326
- index += 10
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
- (byte9 << 63) | ((byte8 & 0x7F) << 56) | ((byte7 & 0x7F) << 49) |
14329
- ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
14330
- ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
14331
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
14332
- else
14333
- raise "integer decoding error"
14334
- end
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
- while val != 0
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
- # Calculate the submessage's size
14421
- submessage_size = buff.bytesize - current_len - 1
14950
+ def to_h
14951
+ result = {}
14422
14952
 
14423
- # Hope the size fits in one byte
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
- # If the sub message was bigger
14430
- if submessage_size > 0
14431
- current_len += 1
14955
+ result
14956
+ end
14432
14957
 
14433
- # compute how much we need to shift
14434
- encoded_int_len = 0
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
- # Make space in the string with dummy bytes
14442
- buff.bytesplice(current_len, 0, "*********", 0, encoded_int_len)
14961
+ tmp_dead_units = @dead_units
14443
14962
 
14444
- # Overwrite the dummy bytes with the encoded length
14445
- while submessage_size != 0
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
- buff
14966
+ result
14456
14967
  end
14457
14968
 
14458
- def to_h
14459
- result = {}
14460
- result["dead_units".to_sym] = @dead_units
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? || newbyte < 0x80
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
- buff.byteslice(index, value)
14727
- index += value
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
- ## END PULL_BYTES
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 val != 0
15887
+ if has_effect_id?
15339
15888
  buff << 0x08
15340
15889
 
15341
- while val != 0
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 val != 0
15953
+ if has_alliance?
15404
15954
  buff << 0x18
15405
15955
 
15406
- while val != 0
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 val != 0
15972
+ if has_owner?
15422
15973
  buff << 0x20
15423
15974
 
15424
- while val != 0
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 val != 0
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
- result["effect_id".to_sym] = @effect_id
15451
- result["pos".to_sym] = @pos
15452
- result["alliance".to_sym] = @alliance
15453
- result["owner".to_sym] = @owner
15454
- result["radius".to_sym] = @radius
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? || newbyte < 0x80
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
- buff.byteslice(index, value)
15658
- index += value
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
- ## END PULL_BYTES
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
- def self.encode(obj)
16236
- obj._encode("".b)
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
- attr_reader :unit_tags
16847
+ def as_json(options = {})
16848
+ result = {}
16241
16849
 
16242
- # optional field readers
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? || newbyte < 0x80
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
- buff.byteslice(index, value)
16510
- index += value
17180
+ val = value
17181
+ loop do
17182
+ byte = val & 0x7F
16511
17183
 
16512
- ## END PULL_BYTES
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 == 0x22
17600
+ if tag == 0x20
16915
17601
  found = true
16916
- ## PULL_UINT64
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
- return self if index >= len
17025
- ## PULL_UINT64
17026
- tag =
17027
- if (byte0 = buff.getbyte(index)) < 0x80
17028
- index += 1
17029
- byte0
17030
- elsif (byte1 = buff.getbyte(index + 1)) < 0x80
17031
- index += 2
17032
- (byte1 << 7) | (byte0 & 0x7F)
17033
- elsif (byte2 = buff.getbyte(index + 2)) < 0x80
17034
- index += 3
17035
- (byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
17036
- elsif (byte3 = buff.getbyte(index + 3)) < 0x80
17037
- index += 4
17038
- (byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
17039
- (byte0 & 0x7F)
17040
- elsif (byte4 = buff.getbyte(index + 4)) < 0x80
17041
- index += 5
17042
- (byte4 << 28) | ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
17043
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
17044
- elsif (byte5 = buff.getbyte(index + 5)) < 0x80
17045
- index += 6
17046
- (byte5 << 35) | ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
17047
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
17048
- elsif (byte6 = buff.getbyte(index + 6)) < 0x80
17049
- index += 7
17050
- (byte6 << 42) | ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
17051
- ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
17052
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
17053
- elsif (byte7 = buff.getbyte(index + 7)) < 0x80
17054
- index += 8
17055
- (byte7 << 49) | ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
17056
- ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
17057
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
17058
- elsif (byte8 = buff.getbyte(index + 8)) < 0x80
17059
- index += 9
17060
- (byte8 << 56) | ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
17061
- ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
17062
- ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
17063
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
17064
- elsif (byte9 = buff.getbyte(index + 9)) < 0x80
17065
- index += 10
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
- (byte9 << 63) | ((byte8 & 0x7F) << 56) | ((byte7 & 0x7F) << 49) |
17068
- ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
17069
- ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
17070
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
17071
- else
17072
- raise "integer decoding error"
17073
- end
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
- ## END PULL_UINT64
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 val != 0
17788
+ if has_ability_id?
17145
17789
  buff << 0x08
17146
17790
 
17147
- while val != 0
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
- while val != 0
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
- while val != 0
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
- # Calculate the submessage's size
17245
- submessage_size = buff.bytesize - current_len - 1
17885
+ if has_queue_command?
17886
+ val = @queue_command
17887
+ buff << 0x28
17246
17888
 
17247
- # Hope the size fits in one byte
17248
- byte = submessage_size & 0x7F
17249
- submessage_size >>= 7
17250
- byte |= 0x80 if submessage_size > 0
17251
- buff.setbyte(current_len, byte)
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
- # If the sub message was bigger
17254
- if submessage_size > 0
17255
- current_len += 1
17899
+ def to_h
17900
+ result = {}
17256
17901
 
17257
- # compute how much we need to shift
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
- # Make space in the string with dummy bytes
17266
- buff.bytesplice(current_len, 0, "*********", 0, encoded_int_len)
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
- # Overwrite the dummy bytes with the encoded length
17269
- while submessage_size != 0
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
- val = @queue_command
17280
- if val == true
17281
- buff << 0x28
17917
+ def as_json(options = {})
17918
+ result = {}
17282
17919
 
17283
- buff << 1
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
- buff
17291
- end
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? || newbyte < 0x80
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
- buff.byteslice(index, value)
17477
- index += value
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
- ## END PULL_BYTES
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
- result["center_world_space".to_sym] = @center_world_space.to_h
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? || newbyte < 0x80
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
- buff.byteslice(index, value)
17921
- index += value
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
- ## END PULL_BYTES
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 == 0x12
18839
+ if tag == 0x10
18105
18840
  found = true
18106
- ## PULL_UINT64
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
- return self if index >= len
18215
- ## PULL_UINT64
18216
- tag =
18217
- if (byte0 = buff.getbyte(index)) < 0x80
18218
- index += 1
18219
- byte0
18220
- elsif (byte1 = buff.getbyte(index + 1)) < 0x80
18221
- index += 2
18222
- (byte1 << 7) | (byte0 & 0x7F)
18223
- elsif (byte2 = buff.getbyte(index + 2)) < 0x80
18224
- index += 3
18225
- (byte2 << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
18226
- elsif (byte3 = buff.getbyte(index + 3)) < 0x80
18227
- index += 4
18228
- (byte3 << 21) | ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) |
18229
- (byte0 & 0x7F)
18230
- elsif (byte4 = buff.getbyte(index + 4)) < 0x80
18231
- index += 5
18232
- (byte4 << 28) | ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
18233
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
18234
- elsif (byte5 = buff.getbyte(index + 5)) < 0x80
18235
- index += 6
18236
- (byte5 << 35) | ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
18237
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
18238
- elsif (byte6 = buff.getbyte(index + 6)) < 0x80
18239
- index += 7
18240
- (byte6 << 42) | ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
18241
- ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
18242
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
18243
- elsif (byte7 = buff.getbyte(index + 7)) < 0x80
18244
- index += 8
18245
- (byte7 << 49) | ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
18246
- ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
18247
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
18248
- elsif (byte8 = buff.getbyte(index + 8)) < 0x80
18249
- index += 9
18250
- (byte8 << 56) | ((byte7 & 0x7F) << 49) | ((byte6 & 0x7F) << 42) |
18251
- ((byte5 & 0x7F) << 35) | ((byte4 & 0x7F) << 28) |
18252
- ((byte3 & 0x7F) << 21) | ((byte2 & 0x7F) << 14) |
18253
- ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
18254
- elsif (byte9 = buff.getbyte(index + 9)) < 0x80
18255
- index += 10
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
- (byte9 << 63) | ((byte8 & 0x7F) << 56) | ((byte7 & 0x7F) << 49) |
18258
- ((byte6 & 0x7F) << 42) | ((byte5 & 0x7F) << 35) |
18259
- ((byte4 & 0x7F) << 28) | ((byte3 & 0x7F) << 21) |
18260
- ((byte2 & 0x7F) << 14) | ((byte1 & 0x7F) << 7) | (byte0 & 0x7F)
18261
- else
18262
- raise "integer decoding error"
18263
- end
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
- ## END PULL_UINT64
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 val != 0
18966
+ if has_ability_id?
18274
18967
  buff << 0x08
18275
18968
 
18276
- while val != 0
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
- while val != 0
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
- # Calculate the submessage's size
18314
- submessage_size = buff.bytesize - current_len - 1
19005
+ def to_h
19006
+ result = {}
18315
19007
 
18316
- # Hope the size fits in one byte
18317
- byte = submessage_size & 0x7F
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
- # If the sub message was bigger
18323
- if submessage_size > 0
18324
- current_len += 1
19011
+ result
19012
+ end
18325
19013
 
18326
- # compute how much we need to shift
18327
- encoded_int_len = 0
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
- # Make space in the string with dummy bytes
18335
- buff.bytesplice(current_len, 0, "*********", 0, encoded_int_len)
19017
+ result["abilityId"] = @ability_id if !options[:compact] || has_ability_id?
19018
+ tmp_unit_tags = @unit_tags
18336
19019
 
18337
- # Overwrite the dummy bytes with the encoded length
18338
- while submessage_size != 0
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
- buff
19023
+ result
18349
19024
  end
18350
19025
 
18351
- def to_h
18352
- result = {}
18353
- result["ability_id".to_sym] = @ability_id
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