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
  RANDOM = 4
12
12
 
13
13
  def self.lookup(val)
14
- if val == 0
15
- :NO_RACE
16
- elsif val == 1
17
- :TERRAN
18
- elsif val == 2
19
- :ZERG
20
- elsif val == 3
21
- :PROTOSS
22
- elsif val == 4
23
- :RANDOM
24
- end
14
+ return :NO_RACE if val == 0
15
+ return :TERRAN if val == 1
16
+ return :ZERG if val == 2
17
+ return :PROTOSS if val == 3
18
+ return :RANDOM if val == 4
25
19
  end
26
20
 
27
21
  def self.resolve(val)
28
- if val == :NO_RACE
29
- 0
30
- elsif val == :TERRAN
31
- 1
32
- elsif val == :ZERG
33
- 2
34
- elsif val == :PROTOSS
35
- 3
36
- elsif val == :RANDOM
37
- 4
38
- end
22
+ return 0 if val == :NO_RACE
23
+ return 1 if val == :TERRAN
24
+ return 2 if val == :ZERG
25
+ return 3 if val == :PROTOSS
26
+ return 4 if val == :RANDOM
39
27
  end
40
28
  end
41
29
 
@@ -172,20 +160,39 @@ module Api
172
160
  # unexpected, so discard it and continue.
173
161
  if !found
174
162
  wire_type = tag & 0x7
163
+
164
+ unknown_bytes = +"".b
165
+ val = tag
166
+ loop do
167
+ byte = val & 0x7F
168
+
169
+ val >>= 7
170
+ # This drops the top bits,
171
+ # Otherwise, with a signed right shift,
172
+ # we get infinity one bits at the top
173
+ val &= (1 << 57) - 1
174
+
175
+ byte |= 0x80 if val != 0
176
+ unknown_bytes << byte
177
+ break if val == 0
178
+ end
179
+
175
180
  case wire_type
176
181
  when 0
177
182
  i = 0
178
183
  while true
179
184
  newbyte = buff.getbyte(index)
180
185
  index += 1
181
- break if newbyte.nil? || newbyte < 0x80
186
+ break if newbyte.nil?
187
+ unknown_bytes << newbyte
188
+ break if newbyte < 0x80
182
189
  i += 1
183
190
  break if i > 9
184
191
  end
185
192
  when 1
193
+ unknown_bytes << buff.byteslice(index, 8)
186
194
  index += 8
187
195
  when 2
188
- ## PULL_BYTES
189
196
  value =
190
197
  if (byte0 = buff.getbyte(index)) < 0x80
191
198
  index += 1
@@ -241,15 +248,30 @@ module Api
241
248
  raise "integer decoding error"
242
249
  end
243
250
 
244
- buff.byteslice(index, value)
245
- index += value
251
+ val = value
252
+ loop do
253
+ byte = val & 0x7F
246
254
 
247
- ## END PULL_BYTES
255
+ val >>= 7
256
+ # This drops the top bits,
257
+ # Otherwise, with a signed right shift,
258
+ # we get infinity one bits at the top
259
+ val &= (1 << 57) - 1
260
+
261
+ byte |= 0x80 if val != 0
262
+ unknown_bytes << byte
263
+ break if val == 0
264
+ end
265
+
266
+ unknown_bytes << buff.byteslice(index, value)
267
+ index += value
248
268
  when 5
269
+ unknown_bytes << buff.byteslice(index, 4)
249
270
  index += 4
250
271
  else
251
272
  raise "unknown wire type #{wire_type}"
252
273
  end
274
+ (@_unknown_fields ||= +"".b) << unknown_bytes
253
275
  return self if index >= len
254
276
  ## PULL_UINT64
255
277
  tag =
@@ -492,10 +514,10 @@ module Api
492
514
  end
493
515
  def _encode(buff)
494
516
  val = @ability_id
495
- if val != 0
517
+ if has_ability_id?
496
518
  buff << 0x08
497
519
 
498
- while val != 0
520
+ loop do
499
521
  byte = val & 0x7F
500
522
 
501
523
  val >>= 7
@@ -506,29 +528,47 @@ module Api
506
528
 
507
529
  byte |= 0x80 if val != 0
508
530
  buff << byte
531
+ break if val == 0
509
532
  end
510
533
  end
511
534
 
512
- val = @requires_point
513
- if val == true
535
+ if has_requires_point?
536
+ val = @requires_point
514
537
  buff << 0x10
515
538
 
516
- buff << 1
517
- elsif val == false
518
- # Default value, encode nothing
519
- else
520
- raise "bool values should be true or false"
539
+ if val == true
540
+ buff << 1
541
+ elsif val == false
542
+ buff << 0
543
+ end
521
544
  end
522
-
545
+ buff << @_unknown_fields if @_unknown_fields
523
546
  buff
524
547
  end
525
548
 
526
549
  def to_h
527
550
  result = {}
528
- result["ability_id".to_sym] = @ability_id
529
- result["requires_point".to_sym] = @requires_point
551
+
552
+ result[:"ability_id"] = @ability_id
553
+ result[:"requires_point"] = @requires_point
554
+
555
+ result
556
+ end
557
+
558
+ def as_json(options = {})
559
+ result = {}
560
+
561
+ result["abilityId"] = @ability_id if !options[:compact] || has_ability_id?
562
+ result["requiresPoint"] = @requires_point if !options[:compact] ||
563
+ has_requires_point?
564
+
530
565
  result
531
566
  end
567
+
568
+ def to_json(as_json_options = {})
569
+ require "json"
570
+ JSON.dump(as_json(as_json_options))
571
+ end
532
572
  end
533
573
  class ImageData
534
574
  def self.decode(buff)
@@ -683,20 +723,39 @@ module Api
683
723
  # unexpected, so discard it and continue.
684
724
  if !found
685
725
  wire_type = tag & 0x7
726
+
727
+ unknown_bytes = +"".b
728
+ val = tag
729
+ loop do
730
+ byte = val & 0x7F
731
+
732
+ val >>= 7
733
+ # This drops the top bits,
734
+ # Otherwise, with a signed right shift,
735
+ # we get infinity one bits at the top
736
+ val &= (1 << 57) - 1
737
+
738
+ byte |= 0x80 if val != 0
739
+ unknown_bytes << byte
740
+ break if val == 0
741
+ end
742
+
686
743
  case wire_type
687
744
  when 0
688
745
  i = 0
689
746
  while true
690
747
  newbyte = buff.getbyte(index)
691
748
  index += 1
692
- break if newbyte.nil? || newbyte < 0x80
749
+ break if newbyte.nil?
750
+ unknown_bytes << newbyte
751
+ break if newbyte < 0x80
693
752
  i += 1
694
753
  break if i > 9
695
754
  end
696
755
  when 1
756
+ unknown_bytes << buff.byteslice(index, 8)
697
757
  index += 8
698
758
  when 2
699
- ## PULL_BYTES
700
759
  value =
701
760
  if (byte0 = buff.getbyte(index)) < 0x80
702
761
  index += 1
@@ -752,15 +811,30 @@ module Api
752
811
  raise "integer decoding error"
753
812
  end
754
813
 
755
- buff.byteslice(index, value)
756
- index += value
814
+ val = value
815
+ loop do
816
+ byte = val & 0x7F
817
+
818
+ val >>= 7
819
+ # This drops the top bits,
820
+ # Otherwise, with a signed right shift,
821
+ # we get infinity one bits at the top
822
+ val &= (1 << 57) - 1
823
+
824
+ byte |= 0x80 if val != 0
825
+ unknown_bytes << byte
826
+ break if val == 0
827
+ end
757
828
 
758
- ## END PULL_BYTES
829
+ unknown_bytes << buff.byteslice(index, value)
830
+ index += value
759
831
  when 5
832
+ unknown_bytes << buff.byteslice(index, 4)
760
833
  index += 4
761
834
  else
762
835
  raise "unknown wire type #{wire_type}"
763
836
  end
837
+ (@_unknown_fields ||= +"".b) << unknown_bytes
764
838
  return self if index >= len
765
839
  ## PULL_UINT64
766
840
  tag =
@@ -1166,10 +1240,10 @@ module Api
1166
1240
  end
1167
1241
  def _encode(buff)
1168
1242
  val = @bits_per_pixel
1169
- if val != 0
1243
+ if has_bits_per_pixel?
1170
1244
  buff << 0x08
1171
1245
 
1172
- while val != 0
1246
+ loop do
1173
1247
  byte = val & 0x7F
1174
1248
 
1175
1249
  val >>= 7
@@ -1180,6 +1254,7 @@ module Api
1180
1254
 
1181
1255
  byte |= 0x80 if val != 0
1182
1256
  buff << byte
1257
+ break if val == 0
1183
1258
  end
1184
1259
  end
1185
1260
 
@@ -1235,26 +1310,47 @@ module Api
1235
1310
  if ((bs = val.bytesize) > 0)
1236
1311
  buff << 0x1a
1237
1312
  len = bs
1238
- while len != 0
1313
+ loop do
1239
1314
  byte = len & 0x7F
1240
1315
  len >>= 7
1241
1316
  byte |= 0x80 if len > 0
1242
1317
  buff << byte
1318
+ break if len == 0
1243
1319
  end
1244
1320
 
1245
1321
  buff.concat(val.b)
1246
1322
  end
1247
-
1323
+ buff << @_unknown_fields if @_unknown_fields
1248
1324
  buff
1249
1325
  end
1250
1326
 
1251
1327
  def to_h
1252
1328
  result = {}
1253
- result["bits_per_pixel".to_sym] = @bits_per_pixel
1254
- result["size".to_sym] = @size.to_h
1255
- result["data".to_sym] = @data
1329
+
1330
+ result[:"bits_per_pixel"] = @bits_per_pixel
1331
+ result[:"size"] = @size.to_h
1332
+ result[:"data"] = @data
1333
+
1334
+ result
1335
+ end
1336
+
1337
+ def as_json(options = {})
1338
+ result = {}
1339
+
1340
+ result["bitsPerPixel"] = @bits_per_pixel if !options[:compact] ||
1341
+ has_bits_per_pixel?
1342
+ result["size"] = @size.nil? ? {} : @size.as_json(options) if !options[
1343
+ :compact
1344
+ ] || has_size?
1345
+ result["data"] = @data if !options[:compact] || has_data?
1346
+
1256
1347
  result
1257
1348
  end
1349
+
1350
+ def to_json(as_json_options = {})
1351
+ require "json"
1352
+ JSON.dump(as_json(as_json_options))
1353
+ end
1258
1354
  end
1259
1355
  class PointI
1260
1356
  def self.decode(buff)
@@ -1398,20 +1494,39 @@ module Api
1398
1494
  # unexpected, so discard it and continue.
1399
1495
  if !found
1400
1496
  wire_type = tag & 0x7
1497
+
1498
+ unknown_bytes = +"".b
1499
+ val = tag
1500
+ loop do
1501
+ byte = val & 0x7F
1502
+
1503
+ val >>= 7
1504
+ # This drops the top bits,
1505
+ # Otherwise, with a signed right shift,
1506
+ # we get infinity one bits at the top
1507
+ val &= (1 << 57) - 1
1508
+
1509
+ byte |= 0x80 if val != 0
1510
+ unknown_bytes << byte
1511
+ break if val == 0
1512
+ end
1513
+
1401
1514
  case wire_type
1402
1515
  when 0
1403
1516
  i = 0
1404
1517
  while true
1405
1518
  newbyte = buff.getbyte(index)
1406
1519
  index += 1
1407
- break if newbyte.nil? || newbyte < 0x80
1520
+ break if newbyte.nil?
1521
+ unknown_bytes << newbyte
1522
+ break if newbyte < 0x80
1408
1523
  i += 1
1409
1524
  break if i > 9
1410
1525
  end
1411
1526
  when 1
1527
+ unknown_bytes << buff.byteslice(index, 8)
1412
1528
  index += 8
1413
1529
  when 2
1414
- ## PULL_BYTES
1415
1530
  value =
1416
1531
  if (byte0 = buff.getbyte(index)) < 0x80
1417
1532
  index += 1
@@ -1467,15 +1582,30 @@ module Api
1467
1582
  raise "integer decoding error"
1468
1583
  end
1469
1584
 
1470
- buff.byteslice(index, value)
1471
- index += value
1585
+ val = value
1586
+ loop do
1587
+ byte = val & 0x7F
1588
+
1589
+ val >>= 7
1590
+ # This drops the top bits,
1591
+ # Otherwise, with a signed right shift,
1592
+ # we get infinity one bits at the top
1593
+ val &= (1 << 57) - 1
1472
1594
 
1473
- ## END PULL_BYTES
1595
+ byte |= 0x80 if val != 0
1596
+ unknown_bytes << byte
1597
+ break if val == 0
1598
+ end
1599
+
1600
+ unknown_bytes << buff.byteslice(index, value)
1601
+ index += value
1474
1602
  when 5
1603
+ unknown_bytes << buff.byteslice(index, 4)
1475
1604
  index += 4
1476
1605
  else
1477
1606
  raise "unknown wire type #{wire_type}"
1478
1607
  end
1608
+ (@_unknown_fields ||= +"".b) << unknown_bytes
1479
1609
  return self if index >= len
1480
1610
  ## PULL_UINT64
1481
1611
  tag =
@@ -1777,10 +1907,10 @@ module Api
1777
1907
  end
1778
1908
  def _encode(buff)
1779
1909
  val = @x
1780
- if val != 0
1910
+ if has_x?
1781
1911
  buff << 0x08
1782
1912
 
1783
- while val != 0
1913
+ loop do
1784
1914
  byte = val & 0x7F
1785
1915
 
1786
1916
  val >>= 7
@@ -1791,14 +1921,15 @@ module Api
1791
1921
 
1792
1922
  byte |= 0x80 if val != 0
1793
1923
  buff << byte
1924
+ break if val == 0
1794
1925
  end
1795
1926
  end
1796
1927
 
1797
1928
  val = @y
1798
- if val != 0
1929
+ if has_y?
1799
1930
  buff << 0x10
1800
1931
 
1801
- while val != 0
1932
+ loop do
1802
1933
  byte = val & 0x7F
1803
1934
 
1804
1935
  val >>= 7
@@ -1809,18 +1940,35 @@ module Api
1809
1940
 
1810
1941
  byte |= 0x80 if val != 0
1811
1942
  buff << byte
1943
+ break if val == 0
1812
1944
  end
1813
1945
  end
1814
-
1946
+ buff << @_unknown_fields if @_unknown_fields
1815
1947
  buff
1816
1948
  end
1817
1949
 
1818
1950
  def to_h
1819
1951
  result = {}
1820
- result["x".to_sym] = @x
1821
- result["y".to_sym] = @y
1952
+
1953
+ result[:"x"] = @x
1954
+ result[:"y"] = @y
1955
+
1956
+ result
1957
+ end
1958
+
1959
+ def as_json(options = {})
1960
+ result = {}
1961
+
1962
+ result["x"] = @x if !options[:compact] || has_x?
1963
+ result["y"] = @y if !options[:compact] || has_y?
1964
+
1822
1965
  result
1823
1966
  end
1967
+
1968
+ def to_json(as_json_options = {})
1969
+ require "json"
1970
+ JSON.dump(as_json(as_json_options))
1971
+ end
1824
1972
  end
1825
1973
  class RectangleI
1826
1974
  def self.decode(buff)
@@ -1946,20 +2094,39 @@ module Api
1946
2094
  # unexpected, so discard it and continue.
1947
2095
  if !found
1948
2096
  wire_type = tag & 0x7
2097
+
2098
+ unknown_bytes = +"".b
2099
+ val = tag
2100
+ loop do
2101
+ byte = val & 0x7F
2102
+
2103
+ val >>= 7
2104
+ # This drops the top bits,
2105
+ # Otherwise, with a signed right shift,
2106
+ # we get infinity one bits at the top
2107
+ val &= (1 << 57) - 1
2108
+
2109
+ byte |= 0x80 if val != 0
2110
+ unknown_bytes << byte
2111
+ break if val == 0
2112
+ end
2113
+
1949
2114
  case wire_type
1950
2115
  when 0
1951
2116
  i = 0
1952
2117
  while true
1953
2118
  newbyte = buff.getbyte(index)
1954
2119
  index += 1
1955
- break if newbyte.nil? || newbyte < 0x80
2120
+ break if newbyte.nil?
2121
+ unknown_bytes << newbyte
2122
+ break if newbyte < 0x80
1956
2123
  i += 1
1957
2124
  break if i > 9
1958
2125
  end
1959
2126
  when 1
2127
+ unknown_bytes << buff.byteslice(index, 8)
1960
2128
  index += 8
1961
2129
  when 2
1962
- ## PULL_BYTES
1963
2130
  value =
1964
2131
  if (byte0 = buff.getbyte(index)) < 0x80
1965
2132
  index += 1
@@ -2015,15 +2182,30 @@ module Api
2015
2182
  raise "integer decoding error"
2016
2183
  end
2017
2184
 
2018
- buff.byteslice(index, value)
2019
- index += value
2185
+ val = value
2186
+ loop do
2187
+ byte = val & 0x7F
2188
+
2189
+ val >>= 7
2190
+ # This drops the top bits,
2191
+ # Otherwise, with a signed right shift,
2192
+ # we get infinity one bits at the top
2193
+ val &= (1 << 57) - 1
2194
+
2195
+ byte |= 0x80 if val != 0
2196
+ unknown_bytes << byte
2197
+ break if val == 0
2198
+ end
2020
2199
 
2021
- ## END PULL_BYTES
2200
+ unknown_bytes << buff.byteslice(index, value)
2201
+ index += value
2022
2202
  when 5
2203
+ unknown_bytes << buff.byteslice(index, 4)
2023
2204
  index += 4
2024
2205
  else
2025
2206
  raise "unknown wire type #{wire_type}"
2026
2207
  end
2208
+ (@_unknown_fields ||= +"".b) << unknown_bytes
2027
2209
  return self if index >= len
2028
2210
  ## PULL_UINT64
2029
2211
  tag =
@@ -2403,16 +2585,36 @@ module Api
2403
2585
 
2404
2586
  buff
2405
2587
  end
2406
-
2588
+ buff << @_unknown_fields if @_unknown_fields
2407
2589
  buff
2408
2590
  end
2409
2591
 
2410
2592
  def to_h
2411
2593
  result = {}
2412
- result["p0".to_sym] = @p0.to_h
2413
- result["p1".to_sym] = @p1.to_h
2594
+
2595
+ result[:"p0"] = @p0.to_h
2596
+ result[:"p1"] = @p1.to_h
2597
+
2598
+ result
2599
+ end
2600
+
2601
+ def as_json(options = {})
2602
+ result = {}
2603
+
2604
+ result["p0"] = @p0.nil? ? {} : @p0.as_json(options) if !options[
2605
+ :compact
2606
+ ] || has_p0?
2607
+ result["p1"] = @p1.nil? ? {} : @p1.as_json(options) if !options[
2608
+ :compact
2609
+ ] || has_p1?
2610
+
2414
2611
  result
2415
2612
  end
2613
+
2614
+ def to_json(as_json_options = {})
2615
+ require "json"
2616
+ JSON.dump(as_json(as_json_options))
2617
+ end
2416
2618
  end
2417
2619
  class Point2D
2418
2620
  def self.decode(buff)
@@ -2538,20 +2740,39 @@ module Api
2538
2740
  # unexpected, so discard it and continue.
2539
2741
  if !found
2540
2742
  wire_type = tag & 0x7
2743
+
2744
+ unknown_bytes = +"".b
2745
+ val = tag
2746
+ loop do
2747
+ byte = val & 0x7F
2748
+
2749
+ val >>= 7
2750
+ # This drops the top bits,
2751
+ # Otherwise, with a signed right shift,
2752
+ # we get infinity one bits at the top
2753
+ val &= (1 << 57) - 1
2754
+
2755
+ byte |= 0x80 if val != 0
2756
+ unknown_bytes << byte
2757
+ break if val == 0
2758
+ end
2759
+
2541
2760
  case wire_type
2542
2761
  when 0
2543
2762
  i = 0
2544
2763
  while true
2545
2764
  newbyte = buff.getbyte(index)
2546
2765
  index += 1
2547
- break if newbyte.nil? || newbyte < 0x80
2766
+ break if newbyte.nil?
2767
+ unknown_bytes << newbyte
2768
+ break if newbyte < 0x80
2548
2769
  i += 1
2549
2770
  break if i > 9
2550
2771
  end
2551
2772
  when 1
2773
+ unknown_bytes << buff.byteslice(index, 8)
2552
2774
  index += 8
2553
2775
  when 2
2554
- ## PULL_BYTES
2555
2776
  value =
2556
2777
  if (byte0 = buff.getbyte(index)) < 0x80
2557
2778
  index += 1
@@ -2607,15 +2828,30 @@ module Api
2607
2828
  raise "integer decoding error"
2608
2829
  end
2609
2830
 
2610
- buff.byteslice(index, value)
2611
- index += value
2831
+ val = value
2832
+ loop do
2833
+ byte = val & 0x7F
2834
+
2835
+ val >>= 7
2836
+ # This drops the top bits,
2837
+ # Otherwise, with a signed right shift,
2838
+ # we get infinity one bits at the top
2839
+ val &= (1 << 57) - 1
2612
2840
 
2613
- ## END PULL_BYTES
2841
+ byte |= 0x80 if val != 0
2842
+ unknown_bytes << byte
2843
+ break if val == 0
2844
+ end
2845
+
2846
+ unknown_bytes << buff.byteslice(index, value)
2847
+ index += value
2614
2848
  when 5
2849
+ unknown_bytes << buff.byteslice(index, 4)
2615
2850
  index += 4
2616
2851
  else
2617
2852
  raise "unknown wire type #{wire_type}"
2618
2853
  end
2854
+ (@_unknown_fields ||= +"".b) << unknown_bytes
2619
2855
  return self if index >= len
2620
2856
  ## PULL_UINT64
2621
2857
  tag =
@@ -2793,28 +3029,44 @@ module Api
2793
3029
  end
2794
3030
  def _encode(buff)
2795
3031
  val = @x
2796
- if val != 0
3032
+ if has_x?
2797
3033
  buff << 0x0d
2798
3034
 
2799
3035
  [val].pack("e", buffer: buff)
2800
3036
  end
2801
3037
 
2802
3038
  val = @y
2803
- if val != 0
3039
+ if has_y?
2804
3040
  buff << 0x15
2805
3041
 
2806
3042
  [val].pack("e", buffer: buff)
2807
3043
  end
2808
-
3044
+ buff << @_unknown_fields if @_unknown_fields
2809
3045
  buff
2810
3046
  end
2811
3047
 
2812
3048
  def to_h
2813
3049
  result = {}
2814
- result["x".to_sym] = @x
2815
- result["y".to_sym] = @y
3050
+
3051
+ result[:"x"] = @x
3052
+ result[:"y"] = @y
3053
+
2816
3054
  result
2817
3055
  end
3056
+
3057
+ def as_json(options = {})
3058
+ result = {}
3059
+
3060
+ result["x"] = @x if !options[:compact] || has_x?
3061
+ result["y"] = @y if !options[:compact] || has_y?
3062
+
3063
+ result
3064
+ end
3065
+
3066
+ def to_json(as_json_options = {})
3067
+ require "json"
3068
+ JSON.dump(as_json(as_json_options))
3069
+ end
2818
3070
  end
2819
3071
  class Point
2820
3072
  def self.decode(buff)
@@ -2959,20 +3211,39 @@ module Api
2959
3211
  # unexpected, so discard it and continue.
2960
3212
  if !found
2961
3213
  wire_type = tag & 0x7
3214
+
3215
+ unknown_bytes = +"".b
3216
+ val = tag
3217
+ loop do
3218
+ byte = val & 0x7F
3219
+
3220
+ val >>= 7
3221
+ # This drops the top bits,
3222
+ # Otherwise, with a signed right shift,
3223
+ # we get infinity one bits at the top
3224
+ val &= (1 << 57) - 1
3225
+
3226
+ byte |= 0x80 if val != 0
3227
+ unknown_bytes << byte
3228
+ break if val == 0
3229
+ end
3230
+
2962
3231
  case wire_type
2963
3232
  when 0
2964
3233
  i = 0
2965
3234
  while true
2966
3235
  newbyte = buff.getbyte(index)
2967
3236
  index += 1
2968
- break if newbyte.nil? || newbyte < 0x80
3237
+ break if newbyte.nil?
3238
+ unknown_bytes << newbyte
3239
+ break if newbyte < 0x80
2969
3240
  i += 1
2970
3241
  break if i > 9
2971
3242
  end
2972
3243
  when 1
3244
+ unknown_bytes << buff.byteslice(index, 8)
2973
3245
  index += 8
2974
3246
  when 2
2975
- ## PULL_BYTES
2976
3247
  value =
2977
3248
  if (byte0 = buff.getbyte(index)) < 0x80
2978
3249
  index += 1
@@ -3028,15 +3299,30 @@ module Api
3028
3299
  raise "integer decoding error"
3029
3300
  end
3030
3301
 
3031
- buff.byteslice(index, value)
3032
- index += value
3302
+ val = value
3303
+ loop do
3304
+ byte = val & 0x7F
3305
+
3306
+ val >>= 7
3307
+ # This drops the top bits,
3308
+ # Otherwise, with a signed right shift,
3309
+ # we get infinity one bits at the top
3310
+ val &= (1 << 57) - 1
3033
3311
 
3034
- ## END PULL_BYTES
3312
+ byte |= 0x80 if val != 0
3313
+ unknown_bytes << byte
3314
+ break if val == 0
3315
+ end
3316
+
3317
+ unknown_bytes << buff.byteslice(index, value)
3318
+ index += value
3035
3319
  when 5
3320
+ unknown_bytes << buff.byteslice(index, 4)
3036
3321
  index += 4
3037
3322
  else
3038
3323
  raise "unknown wire type #{wire_type}"
3039
3324
  end
3325
+ (@_unknown_fields ||= +"".b) << unknown_bytes
3040
3326
  return self if index >= len
3041
3327
  ## PULL_UINT64
3042
3328
  tag =
@@ -3272,36 +3558,53 @@ module Api
3272
3558
  end
3273
3559
  def _encode(buff)
3274
3560
  val = @x
3275
- if val != 0
3561
+ if has_x?
3276
3562
  buff << 0x0d
3277
3563
 
3278
3564
  [val].pack("e", buffer: buff)
3279
3565
  end
3280
3566
 
3281
3567
  val = @y
3282
- if val != 0
3568
+ if has_y?
3283
3569
  buff << 0x15
3284
3570
 
3285
3571
  [val].pack("e", buffer: buff)
3286
3572
  end
3287
3573
 
3288
3574
  val = @z
3289
- if val != 0
3575
+ if has_z?
3290
3576
  buff << 0x1d
3291
3577
 
3292
3578
  [val].pack("e", buffer: buff)
3293
3579
  end
3294
-
3580
+ buff << @_unknown_fields if @_unknown_fields
3295
3581
  buff
3296
3582
  end
3297
3583
 
3298
3584
  def to_h
3299
3585
  result = {}
3300
- result["x".to_sym] = @x
3301
- result["y".to_sym] = @y
3302
- result["z".to_sym] = @z
3586
+
3587
+ result[:"x"] = @x
3588
+ result[:"y"] = @y
3589
+ result[:"z"] = @z
3590
+
3303
3591
  result
3304
3592
  end
3593
+
3594
+ def as_json(options = {})
3595
+ result = {}
3596
+
3597
+ result["x"] = @x if !options[:compact] || has_x?
3598
+ result["y"] = @y if !options[:compact] || has_y?
3599
+ result["z"] = @z if !options[:compact] || has_z?
3600
+
3601
+ result
3602
+ end
3603
+
3604
+ def to_json(as_json_options = {})
3605
+ require "json"
3606
+ JSON.dump(as_json(as_json_options))
3607
+ end
3305
3608
  end
3306
3609
  class Size2DI
3307
3610
  def self.decode(buff)
@@ -3445,20 +3748,39 @@ module Api
3445
3748
  # unexpected, so discard it and continue.
3446
3749
  if !found
3447
3750
  wire_type = tag & 0x7
3751
+
3752
+ unknown_bytes = +"".b
3753
+ val = tag
3754
+ loop do
3755
+ byte = val & 0x7F
3756
+
3757
+ val >>= 7
3758
+ # This drops the top bits,
3759
+ # Otherwise, with a signed right shift,
3760
+ # we get infinity one bits at the top
3761
+ val &= (1 << 57) - 1
3762
+
3763
+ byte |= 0x80 if val != 0
3764
+ unknown_bytes << byte
3765
+ break if val == 0
3766
+ end
3767
+
3448
3768
  case wire_type
3449
3769
  when 0
3450
3770
  i = 0
3451
3771
  while true
3452
3772
  newbyte = buff.getbyte(index)
3453
3773
  index += 1
3454
- break if newbyte.nil? || newbyte < 0x80
3774
+ break if newbyte.nil?
3775
+ unknown_bytes << newbyte
3776
+ break if newbyte < 0x80
3455
3777
  i += 1
3456
3778
  break if i > 9
3457
3779
  end
3458
3780
  when 1
3781
+ unknown_bytes << buff.byteslice(index, 8)
3459
3782
  index += 8
3460
3783
  when 2
3461
- ## PULL_BYTES
3462
3784
  value =
3463
3785
  if (byte0 = buff.getbyte(index)) < 0x80
3464
3786
  index += 1
@@ -3514,15 +3836,30 @@ module Api
3514
3836
  raise "integer decoding error"
3515
3837
  end
3516
3838
 
3517
- buff.byteslice(index, value)
3518
- index += value
3839
+ val = value
3840
+ loop do
3841
+ byte = val & 0x7F
3519
3842
 
3520
- ## END PULL_BYTES
3843
+ val >>= 7
3844
+ # This drops the top bits,
3845
+ # Otherwise, with a signed right shift,
3846
+ # we get infinity one bits at the top
3847
+ val &= (1 << 57) - 1
3848
+
3849
+ byte |= 0x80 if val != 0
3850
+ unknown_bytes << byte
3851
+ break if val == 0
3852
+ end
3853
+
3854
+ unknown_bytes << buff.byteslice(index, value)
3855
+ index += value
3521
3856
  when 5
3857
+ unknown_bytes << buff.byteslice(index, 4)
3522
3858
  index += 4
3523
3859
  else
3524
3860
  raise "unknown wire type #{wire_type}"
3525
3861
  end
3862
+ (@_unknown_fields ||= +"".b) << unknown_bytes
3526
3863
  return self if index >= len
3527
3864
  ## PULL_UINT64
3528
3865
  tag =
@@ -3824,10 +4161,10 @@ module Api
3824
4161
  end
3825
4162
  def _encode(buff)
3826
4163
  val = @x
3827
- if val != 0
4164
+ if has_x?
3828
4165
  buff << 0x08
3829
4166
 
3830
- while val != 0
4167
+ loop do
3831
4168
  byte = val & 0x7F
3832
4169
 
3833
4170
  val >>= 7
@@ -3838,14 +4175,15 @@ module Api
3838
4175
 
3839
4176
  byte |= 0x80 if val != 0
3840
4177
  buff << byte
4178
+ break if val == 0
3841
4179
  end
3842
4180
  end
3843
4181
 
3844
4182
  val = @y
3845
- if val != 0
4183
+ if has_y?
3846
4184
  buff << 0x10
3847
4185
 
3848
- while val != 0
4186
+ loop do
3849
4187
  byte = val & 0x7F
3850
4188
 
3851
4189
  val >>= 7
@@ -3856,17 +4194,34 @@ module Api
3856
4194
 
3857
4195
  byte |= 0x80 if val != 0
3858
4196
  buff << byte
4197
+ break if val == 0
3859
4198
  end
3860
4199
  end
3861
-
4200
+ buff << @_unknown_fields if @_unknown_fields
3862
4201
  buff
3863
4202
  end
3864
4203
 
3865
4204
  def to_h
3866
4205
  result = {}
3867
- result["x".to_sym] = @x
3868
- result["y".to_sym] = @y
4206
+
4207
+ result[:"x"] = @x
4208
+ result[:"y"] = @y
4209
+
4210
+ result
4211
+ end
4212
+
4213
+ def as_json(options = {})
4214
+ result = {}
4215
+
4216
+ result["x"] = @x if !options[:compact] || has_x?
4217
+ result["y"] = @y if !options[:compact] || has_y?
4218
+
3869
4219
  result
3870
4220
  end
4221
+
4222
+ def to_json(as_json_options = {})
4223
+ require "json"
4224
+ JSON.dump(as_json(as_json_options))
4225
+ end
3871
4226
  end
3872
4227
  end