public void CanCreateNewFlatBufferFromScratch()
{
// Second, let's create a FlatBuffer from scratch in C#, and test it also.
// We use an initial size of 1 to exercise the reallocation algorithm,
// normally a size larger than the typical FlatBuffer you generate would be
// better for performance.
var fbb = new FlatBufferBuilder(1);
// We set up the same values as monsterdata.json:
var str = fbb.CreateString("MyMonster");
var test1 = fbb.CreateString("test1");
var test2 = fbb.CreateString("test2");
Monster.StartInventoryVector(fbb, 5);
for (int i = 4; i >= 0; i--)
{
fbb.AddByte((byte)i);
}
var inv = fbb.EndVector();
var fred = fbb.CreateString("Fred");
Monster.StartMonster(fbb);
Monster.AddName(fbb, fred);
var mon2 = Monster.EndMonster(fbb);
Monster.StartTest4Vector(fbb, 2);
MyGame.Example.Test.CreateTest(fbb, (short)10, (sbyte)20);
MyGame.Example.Test.CreateTest(fbb, (short)30, (sbyte)40);
var test4 = fbb.EndVector();
Monster.StartTestarrayofstringVector(fbb, 2);
fbb.AddOffset(test2);
fbb.AddOffset(test1);
var testArrayOfString = fbb.EndVector();
Monster.StartMonster(fbb);
Monster.AddPos(fbb, Vec3.CreateVec3(fbb, 1.0f, 2.0f, 3.0f, 3.0,
Color.Green, (short)5, (sbyte)6));
Monster.AddHp(fbb, (short)80);
Monster.AddName(fbb, str);
Monster.AddInventory(fbb, inv);
Monster.AddTestType(fbb, (byte)1);
Monster.AddTest(fbb, mon2);
Monster.AddTest4(fbb, test4);
Monster.AddTestarrayofstring(fbb, testArrayOfString);
var mon = Monster.EndMonster(fbb);
fbb.Finish(mon);
// Dump to output directory so we can inspect later, if needed
using (var ms = new MemoryStream(fbb.DataBuffer().Data, fbb.DataBuffer().position(), fbb.Offset()))
{
var data = ms.ToArray();
File.WriteAllBytes(@"Resources/monsterdata_cstest.mon",data);
}
// Now assert the buffer
TestBuffer(fbb.DataBuffer());
}
public void TestVector_1xUInt8()
{
var builder = new FlatBufferBuilder(1);
builder.StartVector(sizeof(byte), 1, 1);
Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, builder.DataBuffer.Data);
builder.AddByte(1);
Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, builder.DataBuffer.Data);
builder.EndVector();
Assert.ArrayEqual(new byte[] { 1, 0, 0, 0, 1, 0, 0, 0 }, builder.DataBuffer.Data);
}
public static VectorOffset CreateContextVectorBlock(FlatBufferBuilder builder, Offset <Model>[] data)
{
builder.StartVector(4, data.Length, 4); builder.Add(data); return(builder.EndVector());
}
public static VectorOffset CreatePlayersVectorBlock(FlatBufferBuilder builder, Offset <PlayerInitInfoS>[] data)
{
builder.StartVector(4, data.Length, 4); builder.Add(data); return(builder.EndVector());
}
public static VectorOffset CreateMetadataVectorBlock(FlatBufferBuilder builder, Offset <tflite.Metadata>[] data)
{
builder.StartVector(4, data.Length, 4); builder.Add(data); return(builder.EndVector());
}
public static VectorOffset CreateContentHashesVectorBlock(FlatBufferBuilder builder, Offset <Dragapult.Models.PokecampHashTable>[] data)
{
builder.StartVector(4, data.Length, 4); builder.Add(data); return(builder.EndVector());
}
public static VectorOffset CreateV8VectorBlock(FlatBufferBuilder builder, sbyte[] data)
{
builder.StartVector(1, data.Length, 1); builder.Add(data); return(builder.EndVector());
}
public void TestVTableWithEmptyVector()
{
var builder = new FlatBufferBuilder(1);
builder.StartVector(sizeof(byte), 0, 1);
var vecEnd = builder.EndVector();
builder.StartObject(1);
builder.AddOffset(0, vecEnd.Value, 0);
builder.EndObject();
Assert.ArrayEqual(new byte[]
{
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, // Padding to 32 bytes
6, 0, // vtable bytes
8, 0, // object length inc vtable offset
4, 0, // start of vector offset value 0
6, 0, 0, 0, // int32 offset for start of vtable
4, 0, 0, 0,
0, 0, 0, 0,
},
builder.DataBuffer.Data);
}
public static VectorOffset CreateDevicesVectorBlock(FlatBufferBuilder builder, Offset <NymaTypes.NDeviceInfo>[] data)
{
builder.StartVector(4, data.Length, 4); builder.Add(data); return(builder.EndVector());
}
public static ByteBuffer Save(UnityEngine.Mesh mesh, UnityEngine.Transform[] bones)
{
FlatBufferBuilder builder = new FlatBufferBuilder(InitBufferSize);
// 创建顶点成分
MeshComponent[] components =
{
// vertices
new MeshComponent(
() => { return(true); },
() => { Schema.Mesh.StartVerticesVector(builder, mesh.vertexCount); },
(i) => { Vec3.CreateVec3(builder, mesh.vertices[i].x, mesh.vertices[i].y, mesh.vertices[i].z);},
(vo) => { Schema.Mesh.AddVertices(builder, vo); }
),
// uv
new MeshComponent(
() => { return((mesh.uv != null) && (mesh.uv.Length > 0)); },
() => { Schema.Mesh.StartUvVector(builder, mesh.vertexCount); },
(i) => { Vec2.CreateVec2(builder, mesh.uv[i].x, mesh.uv[i].y); },
(vo) => { Schema.Mesh.AddUv(builder, vo); }
),
// uv2
new MeshComponent(
() => { return((mesh.uv2 != null) && (mesh.uv2.Length > 0)); },
() => { Schema.Mesh.StartUv2Vector(builder, mesh.vertexCount); },
(i) => { Vec2.CreateVec2(builder, mesh.uv2[i].x, mesh.uv2[i].y); },
(vo) => { Schema.Mesh.AddUv2(builder, vo); }
),
// uv3
new MeshComponent(
() => { return((mesh.uv3 != null) && (mesh.uv3.Length > 0)); },
() => { Schema.Mesh.StartUv3Vector(builder, mesh.vertexCount); },
(i) => { Vec2.CreateVec2(builder, mesh.uv3[i].x, mesh.uv3[i].y); },
(vo) => { Schema.Mesh.AddUv3(builder, vo); }
),
// uv4
new MeshComponent(
() => { return((mesh.uv4 != null) && (mesh.uv4.Length > 0)); },
() => { Schema.Mesh.StartUv4Vector(builder, mesh.vertexCount); },
(i) => { Vec2.CreateVec2(builder, mesh.uv4[i].x, mesh.uv4[i].y); },
(vo) => { Schema.Mesh.AddUv4(builder, vo); }
),
// normals
new MeshComponent(
() => { return((mesh.normals != null) && (mesh.normals.Length > 0)); },
() => { Schema.Mesh.StartNormalsVector(builder, mesh.vertexCount); },
(i) => { Vec3.CreateVec3(builder, mesh.normals[i].x, mesh.normals[i].y, mesh.normals[i].z);},
(vo) => { Schema.Mesh.AddNormals(builder, vo); }
),
// tangents
new MeshComponent(
() => { return((mesh.tangents != null) && (mesh.tangents.Length > 0)); },
() => { Schema.Mesh.StartTangentsVector(builder, mesh.vertexCount); },
(i) => { Vec4.CreateVec4(builder, mesh.tangents[i].x, mesh.tangents[i].y, mesh.tangents[i].z, mesh.tangents[i].w);},
(vo) => { Schema.Mesh.AddTangents(builder, vo); }
),
// colors
new MeshComponent(
() => { return((mesh.colors != null) && (mesh.colors.Length > 0)); },
() => { Schema.Mesh.StartColorsVector(builder, mesh.vertexCount); },
(i) => { Schema.Color.CreateColor(builder, mesh.colors[i].a, mesh.colors[i].b, mesh.colors[i].g, mesh.colors[i].r);},
(vo) => { Schema.Mesh.AddColors(builder, vo); }
),
// colors32
new MeshComponent(
() => { return((mesh.colors32 != null) && (mesh.colors.Length > 0)); },
() => { Schema.Mesh.StartColors32Vector(builder, mesh.vertexCount); },
(i) => { Schema.Color32.CreateColor32(builder, mesh.colors32[i].a, mesh.colors32[i].b, mesh.colors32[i].g, mesh.colors32[i].r);},
(vo) => { Schema.Mesh.AddColors32(builder, vo); }
),
// BoneWeigths
new MeshComponent(
() => { return((mesh.boneWeights != null) && (mesh.boneWeights.Length > 0)); },
() => { Schema.Mesh.StartBoneWeightsVector(builder, mesh.vertexCount); },
(i) => { Schema.BoneWeight.CreateBoneWeight(builder,
mesh.boneWeights[i].boneIndex0, mesh.boneWeights[i].boneIndex1, mesh.boneWeights[i].boneIndex2, mesh.boneWeights[i].boneIndex3,
mesh.boneWeights[i].weight0, mesh.boneWeights[i].weight1, mesh.boneWeights[i].weight2, mesh.boneWeights[i].weight3
); },
(vo) => { Schema.Mesh.AddBoneWeights(builder, vo); }
)
};
int componentCount = components.Length;
VectorOffset[] vectorOffsets = new VectorOffset[componentCount];
for (int c = 0; c < componentCount; c++)
{
if (components[c].funcExist())
{
components[c].actStart();
for (int i = mesh.vertexCount - 1; i >= 0; i--) // 添加时顺序颠倒。
{
components[c].actElem(i); // 结构vector不需要AddOffset
}
vectorOffsets[c] = builder.EndVector();
}
}
// 创建 Submesh
Offset <SubMesh>[] offSubmeshes = new Offset <SubMesh> [mesh.subMeshCount];
uint offset = 0;
for (int i = 0; i < mesh.subMeshCount; i++)
{
int[] _is = mesh.GetIndices(i);
offSubmeshes[i] = SubMesh.CreateSubMesh(builder, offset, (uint)_is.Length, (Schema.MeshTopology)mesh.GetTopology(i));
offset += (uint)_is.Length;
}
// 网格所涉及到的骨骼
StringOffset[] offJoints = new StringOffset[bones.Length];
for (int i = 0; i < bones.Length; i++)
{
offJoints[i] = builder.CreateString(bones[i].name);
}
// BindPoses
Schema.Mesh.StartBindposesVector(builder, mesh.bindposes.Length);
for (int i = mesh.bindposes.Length - 1; i >= 0; i--)
{
Matrix4x4 m = mesh.bindposes[i];
Matrix16.CreateMatrix16(builder,
m.m00, m.m01, m.m02, m.m03,
m.m10, m.m11, m.m12, m.m13,
m.m20, m.m21, m.m22, m.m23,
m.m30, m.m31, m.m32, m.m33
);
}
VectorOffset vecBindPoses = builder.EndVector();
// 三角面索引数据 标量数组可以直接添加。
VectorOffset vecTrangles = Schema.Mesh.CreateTrianglesVector(builder, mesh.triangles);
// Submesh 数据
VectorOffset vecSubmeshes = Schema.Mesh.CreateSubmeshesVector(builder, offSubmeshes);
// 涉及到的骨骼
VectorOffset vecJoints = Schema.Mesh.CreateJointsVector(builder, offJoints);
// 放入Mesh
Schema.Mesh.StartMesh(builder);
// 顶点数据
for (int c = 0; c < componentCount; c++)
{
if (components[c].funcExist())
{
components[c].actAdd(vectorOffsets[c]);
}
}
Schema.Mesh.AddTriangles(builder, vecTrangles);
Schema.Mesh.AddSubmeshes(builder, vecSubmeshes);
Schema.Mesh.AddJoints(builder, vecJoints);
Schema.Mesh.AddBindposes(builder, vecBindPoses);
// 边界
Vector3 min = mesh.bounds.min;
Vector3 max = mesh.bounds.max;
Schema.Mesh.AddBound(builder, Schema.Bound.CreateBound(builder, min.x, min.y, min.z, max.x, max.y, max.z));
Offset <Schema.Mesh> offMesh = Schema.Mesh.EndMesh(builder);
builder.Finish(offMesh.Value);
return(builder.DataBuffer);
}
public static VectorOffset CreateDebugsVectorBlock(FlatBufferBuilder builder, Offset <syncnet.DebugRaycast>[] data)
{
builder.StartVector(4, data.Length, 4); builder.Add(data); return(builder.EndVector());
}
public async Task StepAsync(CancellationToken cancellationToken)
{
try
{
if (player != null)
{
var builder = new FlatBufferBuilder(1);
lock (world.Bodies) // wrong kind of lock but might do for now
{
// First try to focus camera on the player if they have
// a fleet alive;
var followFleet = player?.Fleet;
// if the player doesn't have a fleet alive
if (followFleet == null)
{
// check to see if they are spectating a fleet that's alive
if (SpectatingFleet != null && SpectatingFleet.Exists)
{
followFleet = SpectatingFleet;
}
}
if (followFleet == null)
{
// find someone else to watch
followFleet = Player.GetWorldPlayers(world)
.ToList()
.Where(p => p.IsAlive)
.OrderByDescending(p => p.Score * 10000 + (10000 - p.Fleet?.ID ?? 0))
.FirstOrDefault()
?.Fleet;
}
Body followBody = null;
// if we're watching a fleet, watch the center of their fleet
if (followFleet != null)
{
if (world.Hook.FollowFirstShip)
{
followBody = followFleet.Ships.FirstOrDefault();
}
else
{
var center = FleetMath.FleetCenterNaive(followFleet.Ships);
followBody = new Body
{
DefinitionTime = world.Time,
OriginalPosition = center,
Position = center,
Momentum = followFleet.FleetMomentum
};
}
}
// we've found someone to spectate, record it
if (followFleet != player?.Fleet && followFleet != SpectatingFleet)
{
SpectatingFleet = followFleet;
}
// if we haven't found anything to watch yet, watch the first ship we find
if (followBody == null)
{
followBody = player?.World.Bodies.OfType <Ship>().FirstOrDefault();
}
// if we haven't found anything to watch yet, watch anything
if (followBody == null)
{
followBody = player?.World.Bodies.FirstOrDefault();
}
if (followBody != null)
{
var size = 6000;
var viewportHeight = size * 2;
var viewportWidth = size * 2;
var playerViewport = new Envelope(
followBody.Position.X - viewportWidth / 2,
followBody.Position.Y - viewportHeight / 2,
followBody.Position.X + viewportWidth / 2,
followBody.Position.Y + viewportHeight / 2
);
BodyCache.Update(
world.BodiesNear(playerViewport).ToList(),
world.Time
);
var updates = BodyCache.BodiesByError();
var updateBodies = updates.Take((int)this.Bandwidth);
float VELOCITY_SCALE_FACTOR = 5000;
var updatedGroups = BodyCache.GroupsByError().ToList();
var groupsVector = NetWorldView.CreateGroupsVector(builder,
updatedGroups.Select(b =>
{
var serverGroup = b.GroupUpdated;
var caption = builder.CreateString(serverGroup.Caption ?? " ");
var color = builder.CreateString(serverGroup.Color ?? "");
var customData = builder.CreateString(serverGroup.CustomData ?? "");
var group = NetGroup.CreateNetGroup(builder,
group: serverGroup.ID,
type: (byte)serverGroup.GroupType,
captionOffset: caption,
zindex: serverGroup.ZIndex,
owner: serverGroup.OwnerID,
colorOffset: color,
customDataOffset: customData
);
return(group);
}).ToArray());
foreach (var update in updatedGroups)
{
update.GroupClient = update.GroupUpdated.Clone();
}
var groupDeletesVector = NetWorldView.CreateGroupDeletesVector(builder, BodyCache.CollectStaleGroups().Select(b =>
b.GroupUpdated.ID
).ToArray());
NetWorldView.StartUpdatesVector(builder, updateBodies.Count());
foreach (var b in updateBodies)
{
var serverBody = b.BodyUpdated;
var body = NetBody.CreateNetBody(builder,
Id: serverBody.ID,
DefinitionTime: serverBody.DefinitionTime,
originalPosition_X: (short)serverBody.OriginalPosition.X,
originalPosition_Y: (short)serverBody.OriginalPosition.Y,
velocity_X: (short)(serverBody.Momentum.X * VELOCITY_SCALE_FACTOR),
velocity_Y: (short)(serverBody.Momentum.Y * VELOCITY_SCALE_FACTOR),
OriginalAngle: (sbyte)(serverBody.OriginalAngle / MathF.PI * 127),
AngularVelocity: (sbyte)(serverBody.AngularVelocity * 10000),
Size: (byte)(serverBody.Size / 5),
Sprite: (ushort)serverBody.Sprite,
Mode: serverBody.Mode,
Group: serverBody.Group?.ID ?? 0);
}
var updatesVector = builder.EndVector();
foreach (var update in updateBodies)
{
update.BodyClient = update.BodyUpdated.Clone();
}
var deletesVector = NetWorldView.CreateDeletesVector(builder, BodyCache.CollectStaleBuckets().Select(b =>
b.BodyUpdated.ID
).ToArray());
var messages = player.GetMessages();
VectorOffset announcementsVector = new VectorOffset();
if (messages != null && messages.Any())
{
announcementsVector = NetWorldView.CreateAnnouncementsVector(builder, messages.Select(e =>
{
var stringType = builder.CreateString(e.Type);
var stringMessage = builder.CreateString(e.Message);
var stringExtraData = e.ExtraData != null
? builder.CreateString(JsonConvert.SerializeObject(e.ExtraData))
: new StringOffset();
NetAnnouncement.StartNetAnnouncement(builder);
NetAnnouncement.AddType(builder, stringType);
NetAnnouncement.AddText(builder, stringMessage);
if (e.ExtraData != null)
{
NetAnnouncement.AddExtraData(builder, stringExtraData);
}
NetAnnouncement.AddPointsDelta(builder, e.PointsDelta);
return(NetAnnouncement.EndNetAnnouncement(builder));
}).ToArray());
}
StringOffset customOffset = new StringOffset();
if (followFleet?.CustomData != null && followFleet.CustomData != CustomData)
{
customOffset = builder.CreateString(followFleet.CustomData);
}
NetWorldView.StartNetWorldView(builder);
// define camera
var cameraBody = NetBody.CreateNetBody(
builder,
Id: 0,
DefinitionTime: followBody?.DefinitionTime ?? 0,
originalPosition_X: (short)(followBody?.OriginalPosition.X ?? 0),
originalPosition_Y: (short)(followBody?.OriginalPosition.Y ?? 0),
velocity_X: (short)(followBody?.Momentum.X * VELOCITY_SCALE_FACTOR ?? 0),
velocity_Y: (short)(followBody?.Momentum.Y * VELOCITY_SCALE_FACTOR ?? 0),
OriginalAngle: (sbyte)(followBody?.OriginalAngle / MathF.PI / 127 ?? 0),
AngularVelocity: 0,
Size: 0,
Sprite: 0,
Mode: 0,
Group: 0
);
NetWorldView.AddCamera(builder, cameraBody);
NetWorldView.AddIsAlive(builder, player?.IsAlive ?? false);
NetWorldView.AddTime(builder, world.Time);
NetWorldView.AddUpdates(builder, updatesVector);
NetWorldView.AddDeletes(builder, deletesVector);
NetWorldView.AddGroups(builder, groupsVector);
NetWorldView.AddGroupDeletes(builder, groupDeletesVector);
if (messages != null && messages.Any())
{
NetWorldView.AddAnnouncements(builder, announcementsVector);
}
if (followFleet?.CustomData != null && followFleet.CustomData != CustomData)
{
NetWorldView.AddCustomData(builder, customOffset);
}
CustomData = followFleet?.CustomData;
var players = Player.GetWorldPlayers(world);
NetWorldView.AddPlayerCount(builder, (uint)world.AdvertisedPlayerCount);
NetWorldView.AddSpectatorCount(builder, (uint)players.Count(p => p.Connection?.IsSpectating ?? false));
NetWorldView.AddCooldownBoost(builder, (byte)((player?.Fleet?.BoostCooldownStatus * 255) ?? 0));
NetWorldView.AddCooldownShoot(builder, (byte)((player?.Fleet?.ShootCooldownStatus * 255) ?? 0));
NetWorldView.AddWorldSize(builder, (ushort)world.Hook.WorldSize);
if (followFleet != null)
{
// inform the client of which the fleet id
NetWorldView.AddFleetID(builder, (uint)followFleet.ID);
}
else
{
NetWorldView.AddFleetID(builder, 0);
}
var worldView = NetWorldView.EndNetWorldView(builder);
var newHash = world.Hook.GetHashCode();
if (HookHash != newHash)
{
this.Events.Enqueue(new BroadcastEvent
{
EventType = "hook",
Data = JsonConvert.SerializeObject(world.Hook)
});
}
HookHash = newHash;
var q = NetQuantum.CreateNetQuantum(builder, AllMessages.NetWorldView, worldView.Value);
builder.Finish(q.Value);
}
}
await this.SendAsync(builder.DataBuffer, cancellationToken);
if (LeaderboardTime != (world.Leaderboard?.Time ?? 0))
{
LeaderboardTime = (world.Leaderboard?.Time ?? 0);
builder = new FlatBufferBuilder(1);
var stringName = builder.CreateString(world.Leaderboard?.ArenaRecord?.Name ?? " ");
var stringColor = builder.CreateString(world.Leaderboard?.ArenaRecord?.Color ?? " ");
NetLeaderboardEntry.StartNetLeaderboardEntry(builder);
NetLeaderboardEntry.AddColor(builder, stringColor);
NetLeaderboardEntry.AddName(builder, stringName);
NetLeaderboardEntry.AddScore(builder, world.Leaderboard?.ArenaRecord?.Score ?? 0);
NetLeaderboardEntry.AddToken(builder, !string.IsNullOrEmpty(world.Leaderboard?.ArenaRecord?.Token));
var record = NetLeaderboardEntry.EndNetLeaderboardEntry(builder);
var entriesVector = NetLeaderboard.CreateEntriesVector(builder, world.Leaderboard.Entries.Select(e =>
{
// the strings must be created into the buffer before the are referenced
// and before the start of the entry object
stringName = builder.CreateString(e.Name ?? string.Empty);
stringColor = builder.CreateString(e.Color ?? string.Empty);
StringOffset stringModeData = new StringOffset();
if (e.ModeData != null)
{
stringModeData = builder.CreateString(JsonConvert.SerializeObject(e.ModeData));
}
// here's the start of the entry object, after this we can only use
// predefined string offsets
NetLeaderboardEntry.StartNetLeaderboardEntry(builder);
NetLeaderboardEntry.AddFleetID(builder, e.FleetID);
NetLeaderboardEntry.AddName(builder, stringName);
NetLeaderboardEntry.AddColor(builder, stringColor);
NetLeaderboardEntry.AddScore(builder, e.Score);
NetLeaderboardEntry.AddPosition(builder, FromPositionVector(builder, e.Position));
NetLeaderboardEntry.AddToken(builder, !string.IsNullOrEmpty(e.Token));
if (e.ModeData != null)
{
NetLeaderboardEntry.AddModeData(builder, stringModeData);
}
return(NetLeaderboardEntry.EndNetLeaderboardEntry(builder));
}).ToArray());
var stringType = builder.CreateString(world.Leaderboard.Type ?? string.Empty);
NetLeaderboard.StartNetLeaderboard(builder);
NetLeaderboard.AddEntries(builder, entriesVector);
NetLeaderboard.AddType(builder, stringType);
NetLeaderboard.AddRecord(builder, record);
var leaderboardOffset = NetLeaderboard.EndNetLeaderboard(builder);
builder.Finish(NetQuantum.CreateNetQuantum(builder, AllMessages.NetLeaderboard, leaderboardOffset.Value).Value);
await this.SendAsync(builder.DataBuffer, cancellationToken);
}
while (Events.Count > 0)
{
var e = Events.Dequeue();
var eventType = builder.CreateString(e.EventType);
var eventData = builder.CreateString(e.Data);
NetEvent.StartNetEvent(builder);
NetEvent.AddType(builder, eventType);
NetEvent.AddData(builder, eventData);
var eventOffset = NetEvent.EndNetEvent(builder);
builder.Finish(NetQuantum.CreateNetQuantum(builder, AllMessages.NetEvent, eventOffset.Value).Value);
await this.SendAsync(builder.DataBuffer, cancellationToken);
}
}
}
catch (WebSocketException)
{
//Console.WriteLine(e);
throw;
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public static VectorOffset CreateOutputsVectorBlock(FlatBufferBuilder builder, Offset <IntPair>[] data)
{
builder.StartVector(4, data.Length, 4); builder.Add(data); return(builder.EndVector());
}
public static VectorOffset CreateDurationParentIdVectorBlock(FlatBufferBuilder builder, uint[] data)
{
builder.StartVector(4, data.Length, 4); builder.Add(data); return(builder.EndVector());
}
public void TestVTableWith_1xInt16_and_Vector_or_2xInt16()
{
var builder = new FlatBufferBuilder(1);
builder.StartVector(sizeof(short), 2, 1);
builder.AddShort(0x1234);
builder.AddShort(0x5678);
var vecEnd = builder.EndVector();
builder.StartObject(2);
builder.AddOffset(1, vecEnd.Value, 0);
builder.AddShort(0, 55, 0);
builder.EndObject();
Assert.ArrayEqual(new byte[]
{
0, 0, 0, 0, // Padding to 32 bytes
8, 0, // vtable bytes
12, 0, // object length
6, 0, // start of value 0 from end of vtable
8, 0, // start of value 1 from end of buffer
8, 0, 0, 0, // int32 offset for start of vtable
0, 0, 55, 0, // padding + value 0
4, 0, 0, 0, // position of vector from here
2, 0, 0, 0, // length of vector
0x78, 0x56, // vector value 0
0x34, 0x12, // vector value 1
},
builder.DataBuffer.Data);
}
public void TestVTableWithEmptyVectorAndScalars()
{
var builder = new FlatBufferBuilder(1);
builder.StartVector(sizeof(byte), 0, 1);
var vecEnd = builder.EndVector();
builder.StartObject(2);
builder.AddShort(0, 55, 0);
builder.AddOffset(1, vecEnd.Value, 0);
builder.EndObject();
Assert.ArrayEqual(new byte[]
{
0, 0, 0, 0,
0, 0, 0, 0, // Padding to 32 bytes
8, 0, // vtable bytes
12, 0, // object length inc vtable offset
10, 0, // offset to int16 value 0
4, 0, // start of vector offset value 1
8, 0, 0, 0, // int32 offset for start of vtable
8, 0, 0, 0, // value 1
0, 0, 55, 0, // value 0
0, 0, 0, 0, // length of vector (not in sctruc)
},
builder.DataBuffer.Data);
}
public static VectorOffset CreateShapeVectorBlock(FlatBufferBuilder builder, long[] data)
{
builder.StartVector(8, data.Length, 8); builder.Add(data); return(builder.EndVector());
}
public static VectorOffset CreateAgentsVectorBlock(FlatBufferBuilder builder, Offset <syncnet.AgentInfo>[] data)
{
builder.StartVector(4, data.Length, 4); builder.Add(data); return(builder.EndVector());
}
public void CanCreateNewFlatBufferFromScratch()
{
// Second, let's create a FlatBuffer from scratch in C#, and test it also.
// We use an initial size of 1 to exercise the reallocation algorithm,
// normally a size larger than the typical FlatBuffer you generate would be
// better for performance.
var fbb = new FlatBufferBuilder(1);
// We set up the same values as monsterdata.json:
var str = fbb.CreateString("MyMonster");
var test1 = fbb.CreateString("test1");
var test2 = fbb.CreateString("test2");
Monster.StartInventoryVector(fbb, 5);
for (int i = 4; i >= 0; i--)
{
fbb.AddByte((byte)i);
}
var inv = fbb.EndVector();
var fred = fbb.CreateString("Fred");
Monster.StartMonster(fbb);
Monster.AddName(fbb, fred);
var mon2 = Monster.EndMonster(fbb);
Monster.StartTest4Vector(fbb, 2);
MyGame.Example.Test.CreateTest(fbb, (short)10, (sbyte)20);
MyGame.Example.Test.CreateTest(fbb, (short)30, (sbyte)40);
var test4 = fbb.EndVector();
Monster.StartTestarrayofstringVector(fbb, 2);
fbb.AddOffset(test2.Value);
fbb.AddOffset(test1.Value);
var testArrayOfString = fbb.EndVector();
Monster.StartMonster(fbb);
Monster.AddPos(fbb, Vec3.CreateVec3(fbb, 1.0f, 2.0f, 3.0f, 3.0,
Color.Green, (short)5, (sbyte)6));
Monster.AddHp(fbb, (short)80);
Monster.AddName(fbb, str);
Monster.AddInventory(fbb, inv);
Monster.AddTestType(fbb, Any.Monster);
Monster.AddTest(fbb, mon2.Value);
Monster.AddTest4(fbb, test4);
Monster.AddTestarrayofstring(fbb, testArrayOfString);
Monster.AddTestbool(fbb, false);
var mon = Monster.EndMonster(fbb);
Monster.FinishMonsterBuffer(fbb, mon);
// Dump to output directory so we can inspect later, if needed
using (var ms = new MemoryStream(fbb.DataBuffer.Data, fbb.DataBuffer.Position, fbb.Offset))
{
var data = ms.ToArray();
File.WriteAllBytes(@"Resources/monsterdata_cstest.mon",data);
}
// Now assert the buffer
TestBuffer(fbb.DataBuffer);
//Attempt to mutate Monster fields and check whether the buffer has been mutated properly
// revert to original values after testing
Monster monster = Monster.GetRootAsMonster(fbb.DataBuffer);
// mana is optional and does not exist in the buffer so the mutation should fail
// the mana field should retain its default value
Assert.AreEqual(monster.MutateMana((short)10), false);
Assert.AreEqual(monster.Mana, (short)150);
// testType is an existing field and mutating it should succeed
Assert.AreEqual(monster.TestType, Any.Monster);
Assert.AreEqual(monster.MutateTestType(Any.NONE), true);
Assert.AreEqual(monster.TestType, Any.NONE);
Assert.AreEqual(monster.MutateTestType(Any.Monster), true);
Assert.AreEqual(monster.TestType, Any.Monster);
//mutate the inventory vector
Assert.AreEqual(monster.MutateInventory(0, 1), true);
Assert.AreEqual(monster.MutateInventory(1, 2), true);
Assert.AreEqual(monster.MutateInventory(2, 3), true);
Assert.AreEqual(monster.MutateInventory(3, 4), true);
Assert.AreEqual(monster.MutateInventory(4, 5), true);
for (int i = 0; i < monster.InventoryLength; i++)
{
Assert.AreEqual(monster.GetInventory(i), i + 1);
}
//reverse mutation
Assert.AreEqual(monster.MutateInventory(0, 0), true);
Assert.AreEqual(monster.MutateInventory(1, 1), true);
Assert.AreEqual(monster.MutateInventory(2, 2), true);
Assert.AreEqual(monster.MutateInventory(3, 3), true);
Assert.AreEqual(monster.MutateInventory(4, 4), true);
// get a struct field and edit one of its fields
Vec3 pos = monster.Pos;
Assert.AreEqual(pos.X, 1.0f);
pos.MutateX(55.0f);
Assert.AreEqual(pos.X, 55.0f);
pos.MutateX(1.0f);
Assert.AreEqual(pos.X, 1.0f);
TestBuffer(fbb.DataBuffer);
}
public static VectorOffset CreateTilesVectorBlock(FlatBufferBuilder builder, ushort[] data)
{
builder.StartVector(2, data.Length, 2); builder.Add(data); return(builder.EndVector());
}
public static VectorOffset CreateTestCustomObjArraysVectorBlock(FlatBufferBuilder builder, Offset <PositionArray3d>[] data)
{
builder.StartVector(4, data.Length, 4); builder.Add(data); return(builder.EndVector());
}
public static VectorOffset CreateVectorOfStrongReferrablesVectorBlock(FlatBufferBuilder builder, Offset <Referrable>[] data)
{
builder.StartVector(4, data.Length, 4); builder.Add(data); return(builder.EndVector());
}
public static VectorOffset CreateIdentifierTableVectorBlock(FlatBufferBuilder builder, Offset <Dragapult.Models.PokecampTableWrapper>[] data)
{
builder.StartVector(4, data.Length, 4); builder.Add(data); return(builder.EndVector());
}
public static VectorOffset CreateVectorOfNonOwningReferencesVectorBlock(FlatBufferBuilder builder, ulong[] data)
{
builder.StartVector(8, data.Length, 8); builder.Add(data); return(builder.EndVector());
}
private void CanCreateNewFlatBufferFromScratch(bool sizePrefix)
{
// Second, let's create a FlatBuffer from scratch in C#, and test it also.
// We use an initial size of 1 to exercise the reallocation algorithm,
// normally a size larger than the typical FlatBuffer you generate would be
// better for performance.
var fbb = new FlatBufferBuilder(1);
StringOffset[] names = { fbb.CreateString("Frodo"), fbb.CreateString("Barney"), fbb.CreateString("Wilma") };
Offset <Monster>[] off = new Offset <Monster> [3];
Monster.StartMonster(fbb);
Monster.AddName(fbb, names[0]);
off[0] = Monster.EndMonster(fbb);
Monster.StartMonster(fbb);
Monster.AddName(fbb, names[1]);
off[1] = Monster.EndMonster(fbb);
Monster.StartMonster(fbb);
Monster.AddName(fbb, names[2]);
off[2] = Monster.EndMonster(fbb);
var sortMons = Monster.CreateSortedVectorOfMonster(fbb, off);
// We set up the same values as monsterdata.json:
var str = fbb.CreateString("MyMonster");
var test1 = fbb.CreateString("test1");
var test2 = fbb.CreateString("test2");
Monster.StartInventoryVector(fbb, 5);
for (int i = 4; i >= 0; i--)
{
fbb.AddByte((byte)i);
}
var inv = fbb.EndVector();
var fred = fbb.CreateString("Fred");
Monster.StartMonster(fbb);
Monster.AddName(fbb, fred);
var mon2 = Monster.EndMonster(fbb);
Monster.StartTest4Vector(fbb, 2);
MyGame.Example.Test.CreateTest(fbb, (short)10, (sbyte)20);
MyGame.Example.Test.CreateTest(fbb, (short)30, (sbyte)40);
var test4 = fbb.EndVector();
Monster.StartTestarrayofstringVector(fbb, 2);
fbb.AddOffset(test2.Value);
fbb.AddOffset(test1.Value);
var testArrayOfString = fbb.EndVector();
Monster.StartMonster(fbb);
Monster.AddPos(fbb, Vec3.CreateVec3(fbb, 1.0f, 2.0f, 3.0f, 3.0,
Color.Green, (short)5, (sbyte)6));
Monster.AddHp(fbb, (short)80);
Monster.AddName(fbb, str);
Monster.AddInventory(fbb, inv);
Monster.AddTestType(fbb, Any.Monster);
Monster.AddTest(fbb, mon2.Value);
Monster.AddTest4(fbb, test4);
Monster.AddTestarrayofstring(fbb, testArrayOfString);
Monster.AddTestbool(fbb, true);
Monster.AddTestarrayoftables(fbb, sortMons);
var mon = Monster.EndMonster(fbb);
if (sizePrefix)
{
Monster.FinishSizePrefixedMonsterBuffer(fbb, mon);
}
else
{
Monster.FinishMonsterBuffer(fbb, mon);
}
// Dump to output directory so we can inspect later, if needed
#if ENABLE_SPAN_T
var data = fbb.DataBuffer.ToSizedArray();
string filename = @"Resources/monsterdata_cstest" + (sizePrefix ? "_sp" : "") + ".mon";
File.WriteAllBytes(filename, data);
#else
using (var ms = fbb.DataBuffer.ToMemoryStream(fbb.DataBuffer.Position, fbb.Offset))
{
var data = ms.ToArray();
string filename = @"Resources/monsterdata_cstest" + (sizePrefix ? "_sp" : "") + ".mon";
File.WriteAllBytes(filename, data);
}
#endif
// Remove the size prefix if necessary for further testing
ByteBuffer dataBuffer = fbb.DataBuffer;
if (sizePrefix)
{
Assert.AreEqual(ByteBufferUtil.GetSizePrefix(dataBuffer) + FlatBufferConstants.SizePrefixLength,
dataBuffer.Length - dataBuffer.Position);
dataBuffer = ByteBufferUtil.RemoveSizePrefix(dataBuffer);
}
// Now assert the buffer
TestBuffer(dataBuffer);
//Attempt to mutate Monster fields and check whether the buffer has been mutated properly
// revert to original values after testing
Monster monster = Monster.GetRootAsMonster(dataBuffer);
// mana is optional and does not exist in the buffer so the mutation should fail
// the mana field should retain its default value
Assert.AreEqual(monster.MutateMana((short)10), false);
Assert.AreEqual(monster.Mana, (short)150);
// Accessing a vector of sorted by the key tables
Assert.AreEqual(monster.Testarrayoftables(0).Value.Name, "Barney");
Assert.AreEqual(monster.Testarrayoftables(1).Value.Name, "Frodo");
Assert.AreEqual(monster.Testarrayoftables(2).Value.Name, "Wilma");
// Example of searching for a table by the key
Assert.IsTrue(monster.TestarrayoftablesByKey("Frodo") != null);
Assert.IsTrue(monster.TestarrayoftablesByKey("Barney") != null);
Assert.IsTrue(monster.TestarrayoftablesByKey("Wilma") != null);
// testType is an existing field
Assert.AreEqual(monster.TestType, Any.Monster);
//mutate the inventory vector
Assert.AreEqual(monster.MutateInventory(0, 1), true);
Assert.AreEqual(monster.MutateInventory(1, 2), true);
Assert.AreEqual(monster.MutateInventory(2, 3), true);
Assert.AreEqual(monster.MutateInventory(3, 4), true);
Assert.AreEqual(monster.MutateInventory(4, 5), true);
for (int i = 0; i < monster.InventoryLength; i++)
{
Assert.AreEqual(monster.Inventory(i), i + 1);
}
//reverse mutation
Assert.AreEqual(monster.MutateInventory(0, 0), true);
Assert.AreEqual(monster.MutateInventory(1, 1), true);
Assert.AreEqual(monster.MutateInventory(2, 2), true);
Assert.AreEqual(monster.MutateInventory(3, 3), true);
Assert.AreEqual(monster.MutateInventory(4, 4), true);
// get a struct field and edit one of its fields
Vec3 pos = (Vec3)monster.Pos;
Assert.AreEqual(pos.X, 1.0f);
pos.MutateX(55.0f);
Assert.AreEqual(pos.X, 55.0f);
pos.MutateX(1.0f);
Assert.AreEqual(pos.X, 1.0f);
TestBuffer(dataBuffer);
TestObjectAPI(Monster.GetRootAsMonster(dataBuffer));
}
public static VectorOffset CreateTestarrayoftablesVectorBlock(FlatBufferBuilder builder, Offset <Monster>[] data)
{
builder.StartVector(4, data.Length, 4); builder.Add(data); return(builder.EndVector());
}
public static VectorOffset CreateCharactersVectorBlock(FlatBufferBuilder builder, int[] data)
{
builder.StartVector(4, data.Length, 4); builder.Add(data); return(builder.EndVector());
}
public static VectorOffset CreateTestFloatArraysVectorBlock(FlatBufferBuilder builder, float[] data)
{
builder.StartVector(4, data.Length, 4); builder.Add(data); return(builder.EndVector());
}
public Offset <StateUpdate> ToBuffer(FlatBufferBuilder builder)
{
bool builtPoi = false;
bool changedSiteDrive = false;
StringOffset nsd = new StringOffset();
if (!string.IsNullOrEmpty(siteDrive))
{
nsd = builder.CreateString(siteDrive);
changedSiteDrive = true;
}
Offset <TargetPlacement> tPlacement = new Offset <TargetPlacement>();
//build potential updates to the poi
if (poiPlacementObject.isValid)
{
tPlacement = poiPlacementObject.ToBuffer(builder);
builtPoi = true;
}
//build potential new/updated annotations
List <Offset <Annotation> > aOffsets = new List <Offset <Annotation> >();
if (annotationObjects != null)
{
for (int j = 0; j < annotationObjects.Count; j++)
{
if (annotationObjects[j].isValid)
{
aOffsets.Add(annotationObjects[j].ToBuffer(builder));
}
}
}
//build all created room objects
List <Offset <RoomObject> > roOffsets = new List <Offset <RoomObject> >();
for (int i = 0; i < create.Count; i++)
{
roOffsets.Add(create[i].ToBuffer(builder));
}
//build all updated room objects
List <Offset <RoomObject> > ruOffsets = new List <Offset <RoomObject> >();
for (int i = 0; i < update.Count; i++)
{
ruOffsets.Add(update[i].ToBuffer(builder));
}
//build vectors
VectorOffset?deleteOffset = null;
if (delete.Count > 0)
{
StateUpdate.StartDeleteVector(builder, delete.Count);
for (int i = 0; i < delete.Count; i++)
{
//builder.CreateString(delete[i]);
builder.AddInt(delete[i]);
}
deleteOffset = builder.EndVector();
}
VectorOffset?createOffset = null;
if (roOffsets.Count > 0)
{
createOffset = StateUpdate.CreateCreateVector(builder, roOffsets.ToArray());
}
VectorOffset?updateOffset = null;
if (ruOffsets.Count > 0)
{
updateOffset = StateUpdate.CreateUpdateVector(builder, ruOffsets.ToArray());
}
VectorOffset?annotationOffset = null;
if (aOffsets.Count > 0)
{
annotationOffset = StateUpdate.CreateAnnotationsVector(builder, aOffsets.ToArray());
}
//actually build the buffer
StateUpdate.StartStateUpdate(builder);
if (changedSiteDrive)
{
StateUpdate.AddSiteDrive(builder, nsd);
}
if (builtPoi)
{
StateUpdate.AddPoi(builder, tPlacement);
}
if (annotationOffset != null)
{
StateUpdate.AddAnnotations(builder, (VectorOffset)annotationOffset);
}
if (createOffset != null)
{
StateUpdate.AddCreate(builder, (VectorOffset)createOffset);
}
if (updateOffset != null)
{
StateUpdate.AddUpdate(builder, (VectorOffset)updateOffset);
}
if (deleteOffset != null)
{
StateUpdate.AddDelete(builder, (VectorOffset)deleteOffset);
}
var sup = StateUpdate.EndStateUpdate(builder);
return(sup);
}
public static VectorOffset CreateTestDoubleArraysVectorBlock(FlatBufferBuilder builder, double[] data)
{
builder.StartVector(8, data.Length, 8); builder.Add(data); return(builder.EndVector());
}
public static VectorOffset CreateAnimationsVectorBlock(FlatBufferBuilder builder, Offset <Animation>[] data)
{
builder.StartVector(4, data.Length, 4); builder.Add(data); return(builder.EndVector());
}
public static VectorOffset CreateTestBoolArraysVectorBlock(FlatBufferBuilder builder, bool[] data)
{
builder.StartVector(1, data.Length, 1); builder.Add(data); return(builder.EndVector());
}
public static VectorOffset CreateClientsVectorBlock(FlatBufferBuilder builder, Offset <mainServer.schemas.FWaitingRoom.FClient>[] data)
{
builder.StartVector(4, data.Length, 4); builder.Add(data); return(builder.EndVector());
}
public void TestVector_2xUInt16()
{
var builder = new FlatBufferBuilder(1);
builder.StartVector(sizeof(ushort), 2, 1);
Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, builder.DataBuffer.Data);
builder.AddUshort(0xABCD);
Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 0, 0, 0xCD, 0xAB }, builder.DataBuffer.Data);
builder.AddUshort(0xDCBA);
Assert.ArrayEqual(new byte[] { 0, 0, 0, 0, 0xBA, 0xDC, 0xCD, 0xAB }, builder.DataBuffer.Data);
builder.EndVector();
Assert.ArrayEqual(new byte[] { 2, 0, 0, 0, 0xBA, 0xDC, 0xCD, 0xAB }, builder.DataBuffer.Data);
}
public static VectorOffset CreateControlDepsVectorBlock(FlatBufferBuilder builder, StringOffset[] data)
{
builder.StartVector(4, data.Length, 4); builder.Add(data); return(builder.EndVector());
}
public static VectorOffset CreateTestDefineFromGlobal2sVectorBlock(FlatBufferBuilder builder, Offset <Position3d>[] data)
{
builder.StartVector(4, data.Length, 4); builder.Add(data); return(builder.EndVector());
}
public static VectorOffset CreateTestObjArray1sVectorBlock(FlatBufferBuilder builder, Offset <Config.TestObjArray1_>[] data)
{
builder.StartVector(4, data.Length, 4); builder.Add(data); return(builder.EndVector());
}
public void TestVTableWithAVectorOf_2xStructOf_2xInt8()
{
var builder = new FlatBufferBuilder(1);
builder.StartVector(sizeof(byte)*2, 2, 1);
builder.AddByte(33);
builder.AddByte(44);
builder.AddByte(55);
builder.AddByte(66);
var vecEnd = builder.EndVector();
builder.StartObject(1);
builder.AddOffset(0, vecEnd.Value, 0);
builder.EndObject();
Assert.ArrayEqual(new byte[]
{
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, // Padding to 32 bytes
6, 0, // vtable bytes
8, 0, // object length
4, 0, // offset of vector offset
6, 0, 0, 0, // int32 offset for start of vtable
4, 0, 0, 0, // Vector start offset
2, 0, 0, 0, // Vector len
66, // vector 1, 1
55, // vector 1, 0
44, // vector 0, 1
33, // vector 0, 0
},
builder.DataBuffer.Data);
}
