public void LinkFieldSerialization(IServiceProvider serviceProvider, IObjectRepositoryContainer container, string name, string path)
{
// Arrange
var sut = CreateJsonRepositorySerializer(serviceProvider, new ModelObjectSerializationContext(container));
var link = new LazyLink <Page>(container, new ObjectPath(UniqueId.CreateNew(), path));
var linkField = new Field.Builder(serviceProvider)
{
Id = UniqueId.CreateNew(),
Name = name,
Content = FieldContent.NewLink(new FieldLinkContent(link))
}.ToImmutable();
// Act
var json = Serialize(sut, linkField);
using (var stream = new MemoryStream(Encoding.Default.GetBytes(json)))
{
var deserialized = (Field)sut.Deserialize(stream, _ => throw new NotSupportedException());
var deserializedLazyLink = deserialized.Content.MatchOrDefault(matchLink: c => c.Target);
// Assert
Assert.That(deserialized.Id, Is.EqualTo(linkField.Id));
Assert.That(deserialized.Name, Is.EqualTo(name));
Assert.That(deserializedLazyLink.Path.Path, Is.EqualTo(path));
}
}
public void TestTableAddRemoveAndSetColumn()
{
Table table = MakeTableWithOneColumnOfTwoIntArrays(10);
Array nonEqualLengthIntArray = ColumnTests.MakeIntArray(10);
Field field1 = new Field.Builder().Name("f1").DataType(Int32Type.Default).Build();
Column nonEqualLengthColumn = new Column(field1, new[] { nonEqualLengthIntArray });
Assert.Throws <ArgumentException>(() => table.InsertColumn(-1, nonEqualLengthColumn));
Assert.Throws <ArgumentException>(() => table.InsertColumn(1, nonEqualLengthColumn));
Array equalLengthIntArray = ColumnTests.MakeIntArray(20);
Field field2 = new Field.Builder().Name("f2").DataType(Int32Type.Default).Build();
Column equalLengthColumn = new Column(field2, new[] { equalLengthIntArray });
Column existingColumn = table.Column(0);
Table newTable = table.InsertColumn(0, equalLengthColumn);
Assert.Equal(2, newTable.ColumnCount);
Assert.True(newTable.Column(0) == equalLengthColumn);
Assert.True(newTable.Column(1) == existingColumn);
newTable = newTable.RemoveColumn(1);
Assert.Equal(1, newTable.ColumnCount);
Assert.True(newTable.Column(0) == equalLengthColumn);
newTable = table.SetColumn(0, existingColumn);
Assert.True(newTable.Column(0) == existingColumn);
}
public void TestTableFromRecordBatches()
{
RecordBatch recordBatch1 = TestData.CreateSampleRecordBatch(length: 10, true);
RecordBatch recordBatch2 = TestData.CreateSampleRecordBatch(length: 10, true);
IList <RecordBatch> recordBatches = new List <RecordBatch>()
{
recordBatch1, recordBatch2
};
Table table1 = Table.TableFromRecordBatches(recordBatch1.Schema, recordBatches);
Assert.Equal(20, table1.RowCount);
Assert.Equal(21, table1.ColumnCount);
FixedSizeBinaryType type = new FixedSizeBinaryType(17);
Field newField1 = new Field(type.Name, type, false);
Schema newSchema1 = recordBatch1.Schema.SetField(20, newField1);
Assert.Throws <ArgumentException>(() => Table.TableFromRecordBatches(newSchema1, recordBatches));
List <Field> fields = new List <Field>();
Field.Builder fieldBuilder = new Field.Builder();
fields.Add(fieldBuilder.Name("Ints").DataType(Int32Type.Default).Nullable(true).Build());
fieldBuilder = new Field.Builder();
fields.Add(fieldBuilder.Name("Strings").DataType(StringType.Default).Nullable(true).Build());
StructType structType = new StructType(fields);
Field newField2 = new Field(structType.Name, structType, false);
Schema newSchema2 = recordBatch1.Schema.SetField(16, newField2);
Assert.Throws <ArgumentException>(() => Table.TableFromRecordBatches(newSchema2, recordBatches));
}
public void TestListTypeConstructor()
{
var stringField = new Field.Builder().Name("item").DataType(StringType.Default).Build();
var stringType1 = new ListType(stringField);
var stringType2 = new ListType(StringType.Default);
Assert.True(FieldComparer.Equals(stringType1.ValueField, stringType2.ValueField));
Assert.Equal(stringType1.ValueDataType.TypeId, stringType2.ValueDataType.TypeId);
}
private static void CreateField(Field.Builder builder, JsonField jsonField)
{
builder.Name(jsonField.Name)
.DataType(ToArrowType(jsonField.Type))
.Nullable(jsonField.Nullable);
if (jsonField.Metadata != null)
{
builder.Metadata(jsonField.Metadata);
}
}
public void Equality()
{
Field f0_nullable = new Field.Builder().Name("f0").DataType(Int32Type.Default).Build();
Field f0_nonnullable = new Field.Builder().Name("f0").DataType(Int32Type.Default).Nullable(false).Build();
Field f0_other = new Field.Builder().Name("f0").DataType(Int32Type.Default).Build();
Field f0_with_meta = new Field.Builder().Name("f0").DataType(Int32Type.Default).Nullable(true).Metadata("a", "1").Metadata("b", "2").Build();
Assert.True(FieldComparer.Equals(f0_nullable, f0_other));
Assert.False(FieldComparer.Equals(f0_nullable, f0_nonnullable));
Assert.False(FieldComparer.Equals(f0_nullable, f0_with_meta));
}
public void GetFieldByName()
{
Field f0 = new Field.Builder().Name("f0").DataType(Int32Type.Default).Build();
Field f1 = new Field.Builder().Name("f1").DataType(Int8Type.Default).Build();
var schema = new Schema.Builder()
.Field(f0)
.Field(f1)
.Build();
Assert.True(schema.GetFieldByName("f0") == f0 && schema.GetFieldByName("f1") == f1);
}
public void TestMetadataConstruction()
{
var metadata = new Dictionary <string, string> {
{ "foo", "bar" }, { "bizz", "buzz" }
};
var metadata1 = new Dictionary <string, string>(metadata);
Field f0_nullable = new Field.Builder().Name("f0").DataType(Int32Type.Default).Metadata(metadata).Build();
Field f1_nullable = new Field.Builder().Name("f0").DataType(Int32Type.Default).Metadata(metadata1).Build();
Assert.True(metadata.Keys.SequenceEqual(f0_nullable.Metadata.Keys) && metadata.Values.SequenceEqual(f0_nullable.Metadata.Values));
Assert.True(FieldComparer.Equals(f0_nullable, f1_nullable));
}
public void Basics()
{
Field.Builder fb = new Field.Builder();
Field f0_nullable = fb.Name("f0").DataType(Int32Type.Default).Build();
Field f0_nonnullable = fb.Name("f0").DataType(Int32Type.Default).Nullable(false).Build();
Assert.True(f0_nullable.Name == "f0");
Assert.True(f0_nullable.DataType.Name == Int32Type.Default.Name);
Assert.True(f0_nullable.IsNullable);
Assert.False(f0_nonnullable.IsNullable);
}
public void TestStructGetFieldIndex()
{
Field f0_nullable = new Field.Builder().Name("f0").DataType(Int32Type.Default).Build();
Field f1_nullable = new Field.Builder().Name("f1").DataType(StringType.Default).Build();
Field f2_nullable = new Field.Builder().Name("f2").DataType(UInt8Type.Default).Build();
StructType struct_type = new StructType(new[] { f0_nullable, f1_nullable, f2_nullable });
Assert.Equal(0, struct_type.GetFieldIndex("f0"));
Assert.Equal(1, struct_type.GetFieldIndex("f1"));
Assert.Equal(2, struct_type.GetFieldIndex("F2", StringComparer.OrdinalIgnoreCase));
Assert.Equal(-1, struct_type.GetFieldIndex("F2"));
Assert.Equal(-1, struct_type.GetFieldIndex("F2", StringComparer.Ordinal));
Assert.Equal(-1, struct_type.GetFieldIndex("not_found"));
}
public void MetadataConstruction()
{
var metadata0 = new Dictionary <string, string> {
{ "foo", "bar" }, { "bizz", "buzz" }
};
var metadata1 = new Dictionary <string, string> {
{ "foo", "bar" }
};
var metadata0Copy = new Dictionary <string, string>(metadata0);
var metadata1Copy = new Dictionary <string, string>(metadata1);
Field f0 = new Field.Builder().Name("f0").DataType(Int32Type.Default).Build();
Field f1 = new Field.Builder().Name("f1").DataType(UInt8Type.Default).Nullable(false).Build();
Field f2 = new Field.Builder().Name("f2").DataType(StringType.Default).Build();
Field f3 = new Field.Builder().Name("f2").DataType(StringType.Default).Metadata(metadata1Copy).Build();
var schema0 = new Schema.Builder()
.Field(f0)
.Field(f1)
.Field(f2)
.Metadata(metadata0)
.Build();
var schema1 = new Schema.Builder()
.Field(f0)
.Field(f1)
.Field(f2)
.Metadata(metadata1)
.Build();
var schema2 = new Schema.Builder()
.Field(f0)
.Field(f1)
.Field(f2)
.Metadata(metadata0Copy)
.Build();
var schema3 = new Schema.Builder()
.Field(f0)
.Field(f1)
.Field(f3)
.Metadata(metadata0Copy)
.Build();
Assert.True(metadata0.Keys.SequenceEqual(schema0.Metadata.Keys) && metadata0.Values.SequenceEqual(schema0.Metadata.Values));
Assert.True(metadata1.Keys.SequenceEqual(schema1.Metadata.Keys) && metadata1.Values.SequenceEqual(schema1.Metadata.Values));
Assert.True(metadata0.Keys.SequenceEqual(schema2.Metadata.Keys) && metadata0.Values.SequenceEqual(schema2.Metadata.Values));
SchemaComparer.Compare(schema0, schema2);
Assert.Throws <EqualException>(() => SchemaComparer.Compare(schema0, schema1));
Assert.Throws <EqualException>(() => SchemaComparer.Compare(schema2, schema1));
Assert.Throws <EqualException>(() => SchemaComparer.Compare(schema2, schema3));
}
public void TestStructGetFieldByName()
{
Field f0_nullable = new Field.Builder().Name("f0").DataType(Int32Type.Default).Build();
Field f1_nullable = new Field.Builder().Name("f1").DataType(StringType.Default).Build();
Field f2_nullable = new Field.Builder().Name("f2").DataType(UInt8Type.Default).Build();
List <Field> fields = new List <Field>()
{
f0_nullable, f1_nullable, f2_nullable
};
StructType struct_type = new StructType(fields);
FieldComparer.Compare(struct_type.GetFieldByName("f0"), f0_nullable);
FieldComparer.Compare(struct_type.GetFieldByName("f1"), f1_nullable);
FieldComparer.Compare(struct_type.GetFieldByName("f2"), f2_nullable);
Assert.True(struct_type.GetFieldByName("not_found") == null);
}
public static Table MakeTableWithOneColumnOfTwoIntArrays(int lengthOfEachArray)
{
Array intArray = ColumnTests.MakeIntArray(lengthOfEachArray);
Array intArrayCopy = ColumnTests.MakeIntArray(lengthOfEachArray);
Field field = new Field.Builder().Name("f0").DataType(Int32Type.Default).Build();
Schema s0 = new Schema.Builder().Field(field).Build();
Column column = new Column(field, new List <Array> {
intArray, intArrayCopy
});
Table table = new Table(s0, new List <Column> {
column
});
return(table);
}
public void TestStructBasics()
{
Field f0_nullable = new Field.Builder().Name("f0").DataType(Int32Type.Default).Build();
Field f1_nullable = new Field.Builder().Name("f1").DataType(StringType.Default).Build();
Field f2_nullable = new Field.Builder().Name("f2").DataType(UInt8Type.Default).Build();
List <Field> fields = new List <Field>()
{
f0_nullable, f1_nullable, f2_nullable
};
StructType struct_type = new StructType(fields);
var structFields = struct_type.Fields;
Assert.True(FieldComparer.Equals(structFields.ElementAt(0), f0_nullable));
Assert.True(FieldComparer.Equals(structFields.ElementAt(1), f1_nullable));
Assert.True(FieldComparer.Equals(structFields.ElementAt(2), f2_nullable));
}
public void TestColumn()
{
Array intArray = MakeIntArray(10);
Array intArrayCopy = MakeIntArray(10);
Field field = new Field.Builder().Name("f0").DataType(Int32Type.Default).Build();
Column column = new Column(field, new[] { intArray, intArrayCopy });
Assert.True(column.Name == field.Name);
Assert.True(column.Field == field);
Assert.Equal(20, column.Length);
Assert.Equal(0, column.NullCount);
Assert.Equal(field.DataType, column.Type);
Column slice5 = column.Slice(0, 5);
Assert.Equal(5, slice5.Length);
Column sliceFull = column.Slice(2);
Assert.Equal(18, sliceFull.Length);
Column sliceMore = column.Slice(0, 25);
Assert.Equal(20, sliceMore.Length);
}
/// Initializes both sides of the field (has lots of testing material in it.
private void InitField()
{
HumanPlayer.Builder p1Builder = new HumanPlayer.Builder();
AIPlayer.Builder p2Builder = new AIPlayer.Builder();
p1 = p1Builder
.WithHandPositions(p1HandPositions)
.Build();
p2 = p2Builder
.Build();
p2.lifePoints = 500;
p1Deck = new List <Card>
{
new AncientElf(spriteManager),
new FeralImp(spriteManager),
new DarkMagician(spriteManager),
new GreatWhite(spriteManager),
new DarkHole(spriteManager),
new TrapHole(spriteManager)
};
Field.Builder p1FieldBuilder = new Field.Builder();
p1Field = p1FieldBuilder
.WithDeck(p1Deck)
.WithDeckSpriteAndPosition(spriteManager.cardBack, p1DeckPosition)
.WithGraveYardPosition(p1GraveYardPosition)
.WithMonsterPositions(p1MonsterPositions)
.WithMagicAndTrapPositions(p1MagicAndTrapPositions)
.WithFieldCardPosition(p1FieldZonePosition)
.Build();
p2Deck = new List <Card>
{
new AncientElf(spriteManager),
new FeralImp(spriteManager),
new DarkMagician(spriteManager),
new GreatWhite(spriteManager),
new DarkHole(spriteManager),
new CastleWalls(spriteManager)
};
Field.Builder p2FieldBuilder = new Field.Builder();
p2Field = p2FieldBuilder
.WithDeck(p2Deck)
.WithDeckSpriteAndPosition(spriteManager.cardBack, p2DeckPosition)
.WithGraveYardPosition(p2GraveYardPosition)
.WithMonsterPositions(p2MonsterPositions)
.WithMagicAndTrapPositions(p2MagicAndTrapPositions)
.WithFieldCardPosition(p2FieldZonePosition)
.Build();
// Draw cards
DrawCard.Apply(p1, p1Field);
DrawCard.Apply(p1, p1Field);
DrawCard.Apply(p1, p1Field);
DrawCard.Apply(p1, p1Field);
DrawCard.Apply(p1, p1Field);
DrawCard.Apply(p2, p2Field);
DrawCard.Apply(p2, p2Field);
DrawCard.Apply(p2, p2Field);
DrawCard.Apply(p2, p2Field);
DrawCard.Apply(p2, p2Field);
}
private void DoSet(Field field)
{
FieldOperation.Builder operation = FieldOperation.CreateBuilder();
Field.Builder returnField = Field.CreateBuilder().SetKey(field.Key);
switch ((FieldKeyHelper.Program)field.Key.Program)
{
case FieldKeyHelper.Program.D3:
if (field.Key.Group == 2 && field.Key.Field == 3) //CurrentActivity
{
returnField.SetValue(field.Value);
Logger.Trace("{0} set CurrentActivity to {1}", this, field.Value.IntValue);
}
else if (field.Key.Group == 2 && field.Key.Field == 4) //Unknown bool
{
returnField.SetValue(field.Value);
Logger.Trace("{0} set CurrentActivity to {1}", this, field.Value.BoolValue);
}
else if (field.Key.Group == 4 && field.Key.Field == 1) //PartyId
{
if (field.Value.HasMessageValue) //7727 Sends empty SET instead of a CLEAR -Egris
{
EntityId entityId = EntityId.ParseFrom(field.Value.MessageValue);
Channel channel = ChannelManager.GetChannelByEntityId(entityId);
if (LoggedInClient.CurrentChannel != channel)
{
LoggedInClient.CurrentChannel = channel;
returnField.SetValue(
Variant.CreateBuilder().SetMessageValue(channel.BnetEntityId.ToByteString()).Build());
Logger.Trace("{0} set channel to {1}", this, channel);
}
}
else
{
if (LoggedInClient.CurrentChannel != null)
{
returnField.SetValue(Variant.CreateBuilder().SetMessageValue(ByteString.Empty).Build());
Logger.Warn("Emtpy-field: {0}, {1}, {2}", field.Key.Program, field.Key.Group,
field.Key.Field);
}
}
}
else if (field.Key.Group == 4 && field.Key.Field == 2) //JoinPermission
{
//catch to stop Logger.Warn spam on client start and exit
// should D3.4.2 int64 Current screen (0=in-menus, 1=in-menus, 3=in-menus); see ScreenStatus sent to ChannelService.UpdateChannelState call /raist
if (ScreenStatus.Screen != field.Value.IntValue)
{
ScreenStatus =
ScreenStatus.CreateBuilder().SetScreen((int)field.Value.IntValue).SetStatus(0).Build();
returnField.SetValue(Variant.CreateBuilder().SetIntValue(field.Value.IntValue).Build());
Logger.Trace("{0} set current screen to {1}.", this, field.Value.IntValue);
}
}
else if (field.Key.Group == 4 && field.Key.Field == 3) //CallToArmsMessage
{
returnField.SetValue(field.Value);
}
else if (field.Key.Group == 4 && field.Key.Field == 4) //Party IsFull
{
returnField.SetValue(field.Value);
}
else if (field.Key.Group == 5 && field.Key.Field == 5) //Game IsPrivate
{
returnField.SetValue(field.Value);
}
else
{
Logger.Warn("GameAccount: Unknown set-field: {0}, {1}, {2} := {3}", field.Key.Program,
field.Key.Group, field.Key.Field, field.Value);
}
break;
case FieldKeyHelper.Program.BNet:
if (field.Key.Group == 2 && field.Key.Field == 2) // SocialStatus
{
AwayStatus = (AwayStatusFlag)field.Value.IntValue;
returnField.SetValue(Variant.CreateBuilder().SetIntValue((long)AwayStatus).Build());
Logger.Trace("{0} set AwayStatus to {1}.", this, AwayStatus);
}
else if (field.Key.Group == 2 && field.Key.Field == 8)
{
returnField.SetValue((field.Value));
}
else if (field.Key.Group == 2 && field.Key.Field == 10) // AFK
{
returnField.SetValue(field.Value);
Logger.Trace("{0} set AFK to {1}.", this, field.Value.BoolValue);
}
else
{
Logger.Warn("GameAccount: Unknown set-field: {0}, {1}, {2} := {3}", field.Key.Program,
field.Key.Group, field.Key.Field, field.Value);
}
break;
}
//We only update subscribers on fields that actually change values.
if (returnField.HasValue)
{
operation.SetField(returnField);
UpdateSubscribers(Subscribers, new List <FieldOperation> {
operation.Build()
});
}
}
public void TestStructArray()
{
// The following can be improved with a Builder class for StructArray.
List <Field> fields = new List <Field>();
Field.Builder fieldBuilder = new Field.Builder();
fields.Add(fieldBuilder.Name("Strings").DataType(StringType.Default).Nullable(true).Build());
fieldBuilder = new Field.Builder();
fields.Add(fieldBuilder.Name("Ints").DataType(Int32Type.Default).Nullable(true).Build());
StructType structType = new StructType(fields);
StringArray.Builder stringBuilder = new StringArray.Builder();
StringArray stringArray = stringBuilder.Append("joe").AppendNull().AppendNull().Append("mark").Build();
Int32Array.Builder intBuilder = new Int32Array.Builder();
Int32Array intArray = intBuilder.Append(1).Append(2).AppendNull().Append(4).Build();
List <Array> arrays = new List <Array>();
arrays.Add(stringArray);
arrays.Add(intArray);
ArrowBuffer.BitmapBuilder nullBitmap = new ArrowBuffer.BitmapBuilder();
var nullBitmapBuffer = nullBitmap.Append(true).Append(true).Append(false).Append(true).Build();
StructArray structs = new StructArray(structType, 4, arrays, nullBitmapBuffer, 1);
Assert.Equal(4, structs.Length);
Assert.Equal(1, structs.NullCount);
ArrayData[] childArrays = structs.Data.Children; // Data for StringArray and Int32Array
Assert.Equal(2, childArrays.Length);
for (int i = 0; i < childArrays.Length; i++)
{
ArrayData arrayData = childArrays[i];
Assert.Null(arrayData.Children);
if (i == 0)
{
Assert.Equal(ArrowTypeId.String, arrayData.DataType.TypeId);
Array array = new StringArray(arrayData);
StringArray structStringArray = array as StringArray;
Assert.NotNull(structStringArray);
Assert.Equal(structs.Length, structStringArray.Length);
Assert.Equal(stringArray.Length, structStringArray.Length);
Assert.Equal(stringArray.NullCount, structStringArray.NullCount);
for (int j = 0; j < stringArray.Length; j++)
{
Assert.Equal(stringArray.GetString(j), structStringArray.GetString(j));
}
}
if (i == 1)
{
Assert.Equal(ArrowTypeId.Int32, arrayData.DataType.TypeId);
Array array = new Int32Array(arrayData);
Int32Array structIntArray = array as Int32Array;
Assert.NotNull(structIntArray);
Assert.Equal(structs.Length, structIntArray.Length);
Assert.Equal(intArray.Length, structIntArray.Length);
Assert.Equal(intArray.NullCount, structIntArray.NullCount);
for (int j = 0; j < intArray.Length; j++)
{
Assert.Equal(intArray.GetValue(j), structIntArray.GetValue(j));
}
}
}
}
public Field QueryField(FieldKey queryKey)
{
Field.Builder field = Field.CreateBuilder().SetKey(queryKey);
switch ((FieldKeyHelper.Program)queryKey.Program)
{
case FieldKeyHelper.Program.D3:
if (queryKey.Group == 2 && queryKey.Field == 1) // Banner configuration
{
field.SetValue(
Variant.CreateBuilder().SetMessageValue(BannerConfigurationField.Value.ToByteString()).Build
());
}
else if (queryKey.Group == 2 && queryKey.Field == 2) //Hero's EntityId
{
field.SetValue(Variant.CreateBuilder().SetMessageValue(LastPlayedHeroId.ToByteString()).Build());
}
else if (queryKey.Group == 2 && queryKey.Field == 4) //Unknown Bool
{
field.SetValue(Variant.CreateBuilder().SetBoolValue(false).Build());
}
else if (queryKey.Group == 3 && queryKey.Field == 1) // Hero's class (GbidClass)
{
field.SetValue(Variant.CreateBuilder().SetIntValue(CurrentToon.ClassID).Build());
}
else if (queryKey.Group == 3 && queryKey.Field == 2) // Hero's current level
{
field.SetValue(Variant.CreateBuilder().SetIntValue(CurrentToon.Level).Build());
}
else if (queryKey.Group == 3 && queryKey.Field == 3) // Hero's visible equipment
{
field.SetValue(
Variant.CreateBuilder().SetMessageValue(
CurrentToon.HeroVisualEquipmentField.Value.ToByteString()).Build());
}
else if (queryKey.Group == 3 && queryKey.Field == 4) // Hero's flags (gender and such)
{
field.SetValue(
Variant.CreateBuilder().SetIntValue((uint)(CurrentToon.Flags | ToonFlags.AllUnknowns)).
Build());
}
else if (queryKey.Group == 3 && queryKey.Field == 5) // Toon name
{
field.SetValue(Variant.CreateBuilder().SetStringValue(CurrentToon.Name).Build());
}
else if (queryKey.Group == 3 && queryKey.Field == 6)
{
field.SetValue(Variant.CreateBuilder().SetIntValue(0).Build());
}
else if (queryKey.Group == 3 && queryKey.Field == 7)
{
field.SetValue(Variant.CreateBuilder().SetIntValue(0).Build());
}
else if (queryKey.Group == 4 && queryKey.Field == 1) // Channel ID if the client is online
{
if (LoggedInClient != null && LoggedInClient.CurrentChannel != null)
{
field.SetValue(
Variant.CreateBuilder().SetMessageValue(
LoggedInClient.CurrentChannel.D3EntityId.ToByteString()).Build());
}
else
{
field.SetValue(Variant.CreateBuilder().Build());
}
}
else if (queryKey.Group == 4 && queryKey.Field == 2)
// Current screen (all known values are just "in-menu"; also see ScreenStatuses sent in ChannelService.UpdateChannelState)
{
field.SetValue(Variant.CreateBuilder().SetIntValue(ScreenStatus.Screen).Build());
}
else if (queryKey.Group == 4 && queryKey.Field == 4) //Unknown Bool
{
field.SetValue(Variant.CreateBuilder().SetBoolValue(false).Build());
}
else
{
Logger.Warn("GameAccount Unknown query-key: {0}, {1}, {2}", queryKey.Program, queryKey.Group,
queryKey.Field);
}
break;
case FieldKeyHelper.Program.BNet:
if (queryKey.Group == 2 && queryKey.Field == 1) //GameAccount Logged in
{
field.SetValue(Variant.CreateBuilder().SetBoolValue(GameAccountStatusField.Value).Build());
}
else if (queryKey.Group == 2 && queryKey.Field == 2) // Away status
{
field.SetValue(Variant.CreateBuilder().SetIntValue((long)AwayStatus).Build());
}
else if (queryKey.Group == 2 && queryKey.Field == 3) // Program - always D3
{
field.SetValue(Variant.CreateBuilder().SetFourccValue("D3").Build());
}
else if (queryKey.Group == 2 && queryKey.Field == 5) // BattleTag
{
field.SetValue(Variant.CreateBuilder().SetStringValue(Owner.BattleTag).Build());
}
else if (queryKey.Group == 2 && queryKey.Field == 7) // DBAccount.EntityId
{
field.SetValue(Variant.CreateBuilder().SetEntityidValue(Owner.BnetEntityId).Build());
}
else if (queryKey.Group == 2 && queryKey.Field == 10) // AFK
{
field.SetValue(
Variant.CreateBuilder().SetBoolValue(AwayStatus != AwayStatusFlag.Available).Build());
}
else
{
Logger.Warn("GameAccount Unknown query-key: {0}, {1}, {2}", queryKey.Program, queryKey.Group,
queryKey.Field);
}
break;
}
return(field.HasValue ? field.Build() : null);
}
