void Send(int n)
{
var fbb = new FlatBufferBuilder(1);
fbb.Finish(SendMeStat.CreateSendMeStat(fbb, Class.SendMeStat, Class.MonsterStat, 1).Value);
TCPClient.Instance.Send(fbb.SizedByteArray());
}
/// <summary>
/// Generates the bytes.
/// </summary>
/// <returns>System.Byte[].</returns>
internal override byte[] GenerateBytes()
{
byte flags = 0;
if (Properties.IsSupplyMutable)
{
flags += 1;
}
if (Properties.IsTransferable)
{
flags += 2;
}
if (Properties.IsLevyMutable)
{
flags += 4;
}
var builder = new FlatBufferBuilder(1);
// create vectors
var signatureVector = MosaicCreationTransactionBuffer.CreateSignatureVector(builder, new byte[64]);
var signerVector = MosaicCreationTransactionBuffer.CreateSignerVector(builder, GetSigner());
var feeVector = MosaicCreationTransactionBuffer.CreateFeeVector(builder, Fee.ToUInt8Array());
var deadlineVector = MosaicCreationTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array());
var parentIdVector = MosaicCreationTransactionBuffer.CreateParentIdVector(builder, NamespaceId.Id.ToUInt8Array());
var mosaicIdVector = MosaicCreationTransactionBuffer.CreateMosaicIdVector(builder, MosaicId.Id.ToUInt8Array());
var mosaicNameVector = MosaicCreationTransactionBuffer.CreateMosaicNameVector(builder, Encoding.UTF8.GetBytes(MosaicId.MosaicName));
var durationVector = MosaicCreationTransactionBuffer.CreateDurationVector(builder, Properties.Duration.ToUInt8Array());
ushort version = ushort.Parse(NetworkType.GetNetworkByte().ToString("X") + "0" + Version.ToString("X"), System.Globalization.NumberStyles.HexNumber);
// add vectors to buffer
MosaicCreationTransactionBuffer.StartMosaicCreationTransactionBuffer(builder);
MosaicCreationTransactionBuffer.AddSize(builder, (uint)(149 + Encoding.UTF8.GetBytes(MosaicId.MosaicName).ToHexLower().Length / 2));
MosaicCreationTransactionBuffer.AddSignature(builder, signatureVector);
MosaicCreationTransactionBuffer.AddSigner(builder, signerVector);
MosaicCreationTransactionBuffer.AddVersion(builder, version);
MosaicCreationTransactionBuffer.AddType(builder, TransactionTypes.Types.MosaicDefinition.GetValue());
MosaicCreationTransactionBuffer.AddFee(builder, feeVector);
MosaicCreationTransactionBuffer.AddDeadline(builder, deadlineVector);
MosaicCreationTransactionBuffer.AddMosaicId(builder, mosaicIdVector);
MosaicCreationTransactionBuffer.AddParentId(builder, parentIdVector);
MosaicCreationTransactionBuffer.AddNameLength(builder, (byte)(Encoding.UTF8.GetBytes(MosaicId.MosaicName).ToHexLower().Length / 2));
MosaicCreationTransactionBuffer.AddNumOptionalProperties(builder, 1);
MosaicCreationTransactionBuffer.AddFlags(builder, flags);
MosaicCreationTransactionBuffer.AddDivisibility(builder, (byte)Properties.Divisibility);
MosaicCreationTransactionBuffer.AddMosaicName(builder, mosaicNameVector);
MosaicCreationTransactionBuffer.AddIndicateDuration(builder, 2);
MosaicCreationTransactionBuffer.AddDuration(builder, durationVector);
// Calculate size
var codedNamespace = NamespaceCreationTransactionBuffer.EndNamespaceCreationTransactionBuffer(builder);
builder.Finish(codedNamespace.Value);
return(new MosaicCreationTransactionSchema().Serialize(builder.SizedByteArray()));
}
/// <summary>
/// used by Editor Filewatcher Event
/// </summary>
/// <param name="localFile"></param>
/// <returns></returns>
public override FBNetData CreateFBData(FlatBufferBuilder fbbParent, IFBObject child = null)
{
var fileOffset = XFBType.LocalFile.CreateLocalFile(fbbParent, FileLocation,
fbbParent.CreateString(FileName ?? ""),
fbbParent.CreateString(FilePath ?? ""),
fbbParent.CreateString(ResourceGroup ?? ""));
VectorOffset texturesOffset = new VectorOffset();
if (Textures.Count > 0)
{
List <int> texturesOffsets = new List <int>();
foreach (var texture in Textures)
{
texturesOffsets.Add(fbbParent.CreateString(texture.FileName).Value);
}
XFBType.Material.StartTexturesVector(fbbParent, Textures.Count);
foreach (var texture in texturesOffsets)
{
fbbParent.AddOffset(texture);
}
texturesOffset = fbbParent.EndVector();
}
var name = fbbParent.CreateString(Name ?? "");
var offset = XFBType.Material.CreateMaterial(fbbParent, fileOffset, texturesOffset, TextureType, name);
fbbParent.Finish(offset.Value); //!!!!! important ..
return(new FBNetData()
{
_fbData = fbbParent.SizedByteArray(), _offset = offset.Value, Fbb = fbbParent, TypeSafeOffset = offset
}); //bytebuffer
}
public void BuildNestedMonster()
{
const string nestedMonsterName = "NestedMonsterName";
const short nestedMonsterHp = 600;
const short nestedMonsterMana = 1024;
for (int i = 0; i < NumberOfRows; i++)
{
// Create nested buffer as a Monster type
var fbb1 = new FlatBufferBuilder(16);
var str1 = fbb1.CreateString(nestedMonsterName);
Monster.StartMonster(fbb1);
Monster.AddName(fbb1, str1);
Monster.AddHp(fbb1, nestedMonsterHp);
Monster.AddMana(fbb1, nestedMonsterMana);
var monster1 = Monster.EndMonster(fbb1);
Monster.FinishMonsterBuffer(fbb1, monster1);
var fbb1Bytes = fbb1.SizedByteArray();
fbb1 = null;
// Create a Monster which has the first buffer as a nested buffer
var fbb2 = new FlatBufferBuilder(16);
var str2 = fbb2.CreateString("My Monster");
var nestedBuffer = Monster.CreateTestnestedflatbufferVector(fbb2, fbb1Bytes);
Monster.StartMonster(fbb2);
Monster.AddName(fbb2, str2);
Monster.AddHp(fbb2, 50);
Monster.AddMana(fbb2, 32);
Monster.AddTestnestedflatbuffer(fbb2, nestedBuffer);
var monster = Monster.EndMonster(fbb2);
Monster.FinishMonsterBuffer(fbb2, monster);
}
}
public void SendMeetPlayer(string id)
{
FlatBufferBuilder fbb = new FlatBufferBuilder(1024);
var _id = fbb.CreateString(id);
PlayerInfo.StartPlayerInfo(fbb);
PlayerInfo.AddId(fbb, _id);
var playerInfoOffset = PlayerInfo.EndPlayerInfo(fbb);
MeetCommand.StartMeetCommand(fbb);
MeetCommand.AddOtherPlayer(fbb, playerInfoOffset);
var meetCommandOffset = MeetCommand.EndMeetCommand(fbb);
MessageRoot.StartMessageRoot(fbb);
MessageRoot.AddDataType(fbb, Data.MeetCommand);
MessageRoot.AddData(fbb, meetCommandOffset.Value);
var msgRootOffset = MessageRoot.EndMessageRoot(fbb);
MessageRoot.FinishMessageRootBuffer(fbb, msgRootOffset);
byte[] buf = fbb.SizedByteArray();
_writer.BaseStream.Write(buf, 0, buf.Length);
_writer.Flush();
}
public void SendInitialConnectionAck()
{
FlatBufferBuilder fbb = new FlatBufferBuilder(1024);
var playerInfoOffset = FlatCreator.CreatePlayerInfo(fbb, Id, _playerGo.transform.position.x, _playerGo.transform.position.y,
_playerGo.transform.position.z,
_playerGo.transform.rotation.x, _playerGo.transform.rotation.y, _playerGo.transform.rotation.z,
_playerGo.transform.rotation.w);
InitialConnectCommand.StartInitialConnectCommand(fbb);
InitialConnectCommand.AddPlayer(fbb, playerInfoOffset);
var initialCommandOffset = InitialConnectCommand.EndInitialConnectCommand(fbb);
MessageRoot.StartMessageRoot(fbb);
MessageRoot.AddDataType(fbb, Data.InitialConnectCommand);
MessageRoot.AddData(fbb, initialCommandOffset.Value);
var msgRootOffset = MessageRoot.EndMessageRoot(fbb);
MessageRoot.FinishMessageRootBuffer(fbb, msgRootOffset);
byte[] buf = fbb.SizedByteArray();
_writer.BaseStream.Write(buf, 0, buf.Length);
_writer.Flush();
}
internal override byte[] GenerateBytes()
{
var builder = new FlatBufferBuilder(1);
// create vectors
var signatureVector = SecretProofTransactionBuffer.CreateSignatureVector(builder, new byte[64]);
var signerVector = SecretProofTransactionBuffer.CreateSignerVector(builder, GetSigner());
var feeVector = SecretProofTransactionBuffer.CreateFeeVector(builder, Fee.ToUInt8Array());
var deadlineVector = SecretProofTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array());
var secretVector = SecretProofTransactionBuffer.CreateSecretVector(builder, Secret);
var proofVector = SecretProofTransactionBuffer.CreateProofVector(builder, Proof);
ushort version = ushort.Parse(NetworkType.GetNetworkByte().ToString("X") + "0" + Version.ToString("X"), System.Globalization.NumberStyles.HexNumber);
// add vectors
SecretProofTransactionBuffer.StartSecretProofTransactionBuffer(builder);
SecretProofTransactionBuffer.AddSize(builder, (uint)(187 + Proof.Length));
SecretProofTransactionBuffer.AddSignature(builder, signatureVector);
SecretProofTransactionBuffer.AddSigner(builder, signerVector);
SecretProofTransactionBuffer.AddVersion(builder, version);
SecretProofTransactionBuffer.AddType(builder, TransactionTypes.Types.SecretProof.GetValue());
SecretProofTransactionBuffer.AddFee(builder, feeVector);
SecretProofTransactionBuffer.AddDeadline(builder, deadlineVector);
SecretProofTransactionBuffer.AddHashAlgorithm(builder, HashAlgo.GetHashTypeValue());
SecretProofTransactionBuffer.AddSecret(builder, secretVector);
SecretProofTransactionBuffer.AddProofSize(builder, (ushort)Proof.Length);
SecretProofTransactionBuffer.AddProof(builder, proofVector);
// end build
var codedTransfer = SecretProofTransactionBuffer.EndSecretProofTransactionBuffer(builder);
builder.Finish(codedTransfer.Value);
return(new SecretProofTransactionSchema().Serialize(builder.SizedByteArray()));
}
public byte[] makeClient_PacketInfo(Vector3 pos, int Player_Animator, float dirX, float dirZ, float horizontal, float vertical, Vector3 PlayerRotation, string nickName)
{
FlatBufferBuilder fbb = new FlatBufferBuilder(1);
fbb.Clear(); // 클리어를 안해주고 시작하면 계속 누적해서 데이터가 들어간다.
var fbbNickName = fbb.CreateString(nickName); // String 문자열이 있을경우 미리 생성해라.
Client_info.StartClient_info(fbb);
Client_info.AddAnimator(fbb, Player_Animator);
Client_info.AddDirX(fbb, dirX);
Client_info.AddDirZ(fbb, dirZ);
Client_info.AddHorizontal(fbb, horizontal);
Client_info.AddVertical(fbb, vertical);
Client_info.AddName(fbb, fbbNickName);
Client_info.AddPosition(fbb, Vec3.CreateVec3(fbb, pos.x, pos.y, pos.z));
Client_info.AddRotation(fbb, Vec3.CreateVec3(fbb, PlayerRotation.x, PlayerRotation.y, PlayerRotation.z));
var endOffset = Client_info.EndClient_info(fbb);
fbb.Finish(endOffset.Value);
byte[] packet = fbb.SizedByteArray(); // flatbuffers 실제 패킷 데이터
byte[] magic_packet = makePacketinfo(packet.Length, CS_INFO);
byte[] real_packet = new byte[packet.Length + 8];
System.Buffer.BlockCopy(magic_packet, 0, real_packet, 0, magic_packet.Length);
System.Buffer.BlockCopy(packet, 0, real_packet, 8, packet.Length);
return(real_packet);
}
public byte[] SerializeNetchan(int seq, int ack)
{
var builder = new FlatBufferBuilder(1);
var plays = new Offset <Player> [1];
Player.StartPlayer(builder);
Player.AddId(builder, 1);
var pos = Vec3.CreateVec3(builder, player.position.x, player.position.y, player.position.z);
Player.AddPos(builder, pos);
var rot = Vec3.CreateVec3(builder, player.localEulerAngles.x, player.localEulerAngles.y, player.localEulerAngles.z);
Player.AddRot(builder, rot);
var p1 = Player.EndPlayer(builder);
plays[0] = p1;
// serialize FlatBuffer data
var players = Netchan.CreatePlayersVector(builder, plays);
Netchan.StartNetchan(builder);
Netchan.AddProtocol(builder, 1234);
Netchan.AddSequence(builder, seq);
Netchan.AddAck(builder, ack);
Netchan.AddPlayers(builder, players);
var net = Netchan.EndNetchan(builder);
builder.Finish(net.Value);
var buf = builder.SizedByteArray();
return(buf);
}
internal byte[] Serialize()
{
FlatBufferBuilder fbb = new FlatBufferBuilder(1);
//serialize players
GameResultInfoS.StartPlayerResultsVector(fbb, PlayerResults.Count);
var playersOffset = new Offset <PlayerResultInfoS> [PlayerResults.Count];
for (int i = 0; i < PlayerResults.Count; i++)
{
playersOffset[i] = PlayerResults[i].Create(ref fbb);
}
//nested tables needs to be CREATED before START
VectorOffset playersVectorOffset = GameResultInfoS.CreatePlayerResultsVector(fbb, playersOffset);
//serialize whole game init info
GameResultInfoS.StartGameResultInfoS(fbb);
GameResultInfoS.AddPlayTime(fbb, PlayTime);
GameResultInfoS.AddPlayerResults(fbb, playersVectorOffset);
Offset <GameResultInfoS> gameResultInfoOffset = GameResultInfoS.EndGameResultInfoS(fbb);
fbb.Finish(gameResultInfoOffset.Value);
byte[] result = fbb.SizedByteArray();
return(result);
}
private void btnSendToClient_Click(object sender, RoutedEventArgs e)
{
//var model = this.DataContext as SocketServerToolModel;
//foreach(var item in model.SourceItems)
//{
// foreach (var sceneitem in item.SceneItem.Items)
// {
// var sendItem = sceneitem as SceneItem;
// if(sendItem != null)
// _client.SendToServer(0, sendItem.FBObject.CreateByteBuffer()._fbData, ENet.PacketFlags.Reliable);
// }
//}
// XFBType.
FlatBufferBuilder fbb = new FlatBufferBuilder(4);
var offset = NetMsg.Login.CreateLogin(fbb, fbb.CreateString("xx"));
var mon = NetMsg.MessageRoot.CreateMessageRoot(fbb, 0, 1, NetMsg.Data.Login, offset.Value);
NetMsg.MessageRoot.FinishMessageRootBuffer(fbb, mon);
var _SocketServerManager = VEFModule.UnityContainer.Resolve(typeof(SocketServerManager), "") as SocketServerManager;
_SocketServerManager.Client.SendToServer(0, fbb.SizedByteArray(), ENet.PacketFlags.Reliable);
}
/// <summary>
/// </summary>
/// <param name="states"></param>
/// <param name="simulator_configuration"></param>
/// <param name="serialise_individual_observables"></param>
/// <param name="do_serialise_unobservables"></param>
/// <param name="do_serialise_observables"></param>
/// <param name="api_version"></param>
/// <returns></returns>
public static byte[] Serialise(EnvironmentSnapshot[] states,
SimulatorConfigurationMessage simulator_configuration = null,
bool do_serialise_unobservables = false,
bool serialise_individual_observables = false,
bool do_serialise_observables = false,
string api_version = "N/A")
{
var b = new FlatBufferBuilder(1);
var state_offsets = new Offset <FState> [states.Length];
var i = 0;
foreach (var state in states)
{
state_offsets[i++] = SerialiseState(b,
state,
do_serialise_unobservables,
do_serialise_observables,
serialise_individual_observables:
serialise_individual_observables);
}
var states_vector_offset = FStates.CreateStatesVector(b, state_offsets);
var api_version_offset = b.CreateString(api_version);
FStates.StartFStates(b);
FStates.AddStates(b, states_vector_offset);
FStates.AddApiVersion(b, api_version_offset);
FStates.AddSimulatorConfiguration(b, Serialise(b, simulator_configuration));
var states_offset = FStates.EndFStates(b);
FStates.FinishFStatesBuffer(b, states_offset);
return(b.SizedByteArray());
}
private void SendUpdateToServer <T>()
{
var _SocketServerManager = VEFModule.UnityContainer.Resolve(typeof(SocketServerManager), "") as SocketServerManager;
if (Parent == null)
{
return;
}
var body = Parent as CharacterComponent;
EntityX entity = body.Parent as EntityX;
if (entity != null)
{
List <Type> types = new List <Type>()
{
typeof(T)
};
FlatBufferBuilder fbb = new FlatBufferBuilder(4);
if (entity.FB_Entity == null)
{
return;
}
var fbEntity = entity.FB_Entity.CreateFBData(types, fbb);
var mon = NetMsg.MessageRoot.CreateMessageRoot(fbb, entity.NetID, 1, NetMsg.Data.Entity, fbEntity._offset);
NetMsg.MessageRoot.FinishMessageRootBuffer(fbb, mon);
_SocketServerManager.Client.SendToServer(0, fbb.SizedByteArray(), ENet.PacketFlags.Reliable);
}
}
public void Update()
{
var fbb = new FlatBufferBuilder(1);
fbb.Finish(ping.Createping(fbb, Class.ping, System.DateTime.Now.ToBinary()).Value);
TCPClient.Instance.Send(fbb.SizedByteArray());
}
private void FinishBakeJob()
{
var pixels = _currentBakeJob.Finish();
int pixelCount = _currentBakeJob.Resolution * _currentBakeJob.Resolution;
var arraySize = 4 * 3 * pixelCount;
arraySize += 4 * 4;
var builder = new FlatBufferBuilder(arraySize);
WorkloadComplete.StartResultsVector(builder, pixelCount);
foreach (var color in pixels)
{
Vec3.CreateVec3(builder, color.r, color.g, color.b);
}
var resultsVectorOffset = builder.EndVector();
WorkloadComplete.StartWorkloadComplete(builder);
WorkloadComplete.AddResults(builder, resultsVectorOffset);
WorkloadComplete.AddWorkloadID(builder, _currentBakeJob.JobID);
var messageDataOffset = WorkloadComplete.EndWorkloadComplete(builder);
Message.StartMessage(builder);
Message.AddData(builder, messageDataOffset.Value);
Message.AddDataType(builder, MessageDatum.WorkloadComplete);
var messageOffset = Message.EndMessage(builder);
builder.Finish(messageOffset.Value);
var byteArray = builder.SizedByteArray();
_currentBakeJob = null;
_outgoingMessages.Enqueue(byteArray);
}
internal override byte[] GenerateBytes()
{
var builder = new FlatBufferBuilder(1);
var mosaicName = Encoding.UTF8.GetBytes(MosaicId.Name);
var namespaceName = Encoding.UTF8.GetBytes(MosaicId.NamespaceId.Name);
var signerVector = SupplyChangeBuffer.CreatePublicKeyVector(builder, GetSigner());
var namespaceVector = SupplyChangeBuffer.CreateNamespaceIdstringVector(builder, namespaceName);
var mosaicNameVector = SupplyChangeBuffer.CreateMosaicNameStringVector(builder, mosaicName);
SupplyChangeBuffer.StartSupplyChangeBuffer(builder);
SupplyChangeBuffer.AddTransactionType(builder, TransactionType.GetValue());
SupplyChangeBuffer.AddVersion(builder, BitConverter.ToInt16(new byte[] { ExtractVersion(Version), 0 }, 0));
SupplyChangeBuffer.AddNetwork(builder, BitConverter.ToInt16(new byte[] { 0, NetworkType.GetNetwork() }, 0));
SupplyChangeBuffer.AddTimestamp(builder, NetworkTime.EpochTimeInMilliSeconds());
SupplyChangeBuffer.AddPublicKeyLen(builder, 32);
SupplyChangeBuffer.AddPublicKey(builder, signerVector);
SupplyChangeBuffer.AddFee(builder, Fee);
SupplyChangeBuffer.AddDeadline(builder, Deadline.Ticks);
SupplyChangeBuffer.AddLengthOfMosaicIdStructure(builder, 8 + namespaceName.Length + mosaicName.Length);
SupplyChangeBuffer.AddLengthOfNamespaceIdString(builder, namespaceName.Length);
SupplyChangeBuffer.AddNamespaceIdstring(builder, namespaceVector);
SupplyChangeBuffer.AddLengthOfMosaicNameString(builder, mosaicName.Length);
SupplyChangeBuffer.AddMosaicNameString(builder, mosaicNameVector);
SupplyChangeBuffer.AddSupplyType(builder, SupplyType);
SupplyChangeBuffer.AddDelta(builder, Delta);
var codedTransfer = ImportanceTransferBuffer.EndImportanceTransferBuffer(builder);
builder.Finish(codedTransfer.Value);
return(new SupplyChangeTransactionSchema().Serialize(builder.SizedByteArray()));
}
/// <summary>
/// Sets the bot's controller inputs.
/// </summary>
/// <param name="controller">The controller to set the inputs to.</param>
/// <param name="index">The index of the bot's car.</param>
public static void SetBotInput(Controller controller, int index)
{
FlatBufferBuilder builder = new FlatBufferBuilder(50);
Offset <ControllerState> controllerStateOffset = ControllerState.CreateControllerState(
builder,
controller.Throttle,
controller.Steer,
controller.Pitch,
controller.Yaw,
controller.Roll,
controller.Jump,
controller.Boost,
controller.Handbrake,
controller.UseItem);
Offset <PlayerInput> playerInputOffset = PlayerInput.CreatePlayerInput(
builder,
index,
controllerStateOffset);
builder.Finish(playerInputOffset.Value);
byte[] bufferBytes = builder.SizedByteArray();
int status = UpdatePlayerInputFlatbuffer(bufferBytes, bufferBytes.Length);
if (status > 0)
{
throw NewRLBotCoreException((RLBotCoreStatus)status);
}
}
internal override byte[] GenerateBytes()
{
var builder = new FlatBufferBuilder(1);
var signer = ImportanceTransferBuffer.CreatePublicKeyVector(builder, GetSigner());
var remote = ImportanceTransferBuffer.CreateRemotePublicKeyVector(builder, RemoteAccount.PublicKey.FromHex());
ImportanceTransferBuffer.StartImportanceTransferBuffer(builder);
ImportanceTransferBuffer.AddTransactionType(builder, TransactionType.GetValue());
ImportanceTransferBuffer.AddVersion(builder, BitConverter.ToInt16(new byte[] { ExtractVersion(Version), 0 }, 0));
ImportanceTransferBuffer.AddNetwork(builder, BitConverter.ToInt16(new byte[] { 0, NetworkType.GetNetwork() }, 0));
ImportanceTransferBuffer.AddTimestamp(builder, NetworkTime.EpochTimeInMilliSeconds());
ImportanceTransferBuffer.AddPublicKeyLen(builder, 32);
ImportanceTransferBuffer.AddPublicKey(builder, signer);
ImportanceTransferBuffer.AddFee(builder, Fee);
ImportanceTransferBuffer.AddDeadline(builder, Deadline.TimeStamp);
ImportanceTransferBuffer.AddMode(builder, Mode.GetValue());
ImportanceTransferBuffer.AddRemotePublicKeyLen(builder, 32);
ImportanceTransferBuffer.AddRemotePublicKey(builder, remote);
var codedTransfer = ImportanceTransferBuffer.EndImportanceTransferBuffer(builder);
builder.Finish(codedTransfer.Value);
return(new ImportanceTransferSchema().Serialize(builder.SizedByteArray()));
}
public static void KeySlotUpdate()
{
int[] m_kslot = new int[30];
for (int i = 0; i < 4; i++)
{
if (instance.Slots[i].Item != null)
{
if (((KeySlot)instance.Slots[i]).mItemSlotType == Slot.SlotType.Skill)
{
m_kslot[i] = -instance.Slots[i].Item.id;
}
else
{
m_kslot[i] = instance.Slots[i].Item.id;
}
}
else
{
m_kslot[i] = 0;
}
}
var fbb = new FlatBufferBuilder(1);
fbb.Finish(fKeySlot.CreatefKeySlot(fbb, Class.fKeySlot, fKeySlot.CreateSlotNumVector(fbb, m_kslot)).Value);
TCPClient.Instance.Send(fbb.SizedByteArray());
}
internal override byte[] GenerateBytes()
{
var innerTransactionBytes = InnerTransaction.GenerateBytes();
var builder = new FlatBufferBuilder(1);
var signer = MultisigTransactionBuffer.CreatePublicKeyVector(builder, GetSigner());
var innerTransaction = MultisigTransactionBuffer.CreateInnerTransactionBytesVector(builder, innerTransactionBytes);
MultisigTransactionBuffer.StartMultisigTransactionBuffer(builder);
MultisigTransactionBuffer.AddTransactionType(builder, TransactionType.GetValue());
MultisigTransactionBuffer.AddVersion(builder, BitConverter.ToInt16(new byte[] { ExtractVersion(Version), 0 }, 0));
MultisigTransactionBuffer.AddNetwork(builder, BitConverter.ToInt16(new byte[] { 0, NetworkType.GetNetwork() }, 0));
MultisigTransactionBuffer.AddTimestamp(builder, NetworkTime.EpochTimeInMilliSeconds());
MultisigTransactionBuffer.AddPublicKeyLen(builder, 32);
MultisigTransactionBuffer.AddPublicKey(builder, signer);
MultisigTransactionBuffer.AddFee(builder, Fee);
MultisigTransactionBuffer.AddDeadline(builder, Deadline.Ticks);
MultisigTransactionBuffer.AddInnerTransactionLength(builder, innerTransactionBytes.Length);
MultisigTransactionBuffer.AddInnerTransactionBytes(builder, innerTransaction);
var codedTransfer = MultisigTransactionBuffer.EndMultisigTransactionBuffer(builder);
builder.Finish(codedTransfer.Value);
return(new MultisigTransactionSchema().Serialize(builder.SizedByteArray()));
}
public GameStatePacket BuildGameStatePacket()
{
FlatBufferBuilder builder = new FlatBufferBuilder(100);
int ballStateOffset = -1;
if (BallState != null)
{
ballStateOffset = BallState.ToFlatBuffer(builder).Value;
}
VectorOffset carStateVector = CreateCarStateVector(builder, carStates);
DesiredGameState.StartDesiredGameState(builder);
if (BallState != null)
{
DesiredGameState.AddBallState(builder, new Offset <DesiredBallState>(ballStateOffset));
}
DesiredGameState.AddCarStates(builder, carStateVector);
builder.Finish(DesiredGameState.EndDesiredGameState(builder).Value);
return(new GameStatePacket(builder.SizedByteArray()));
}
public byte[] GetResultBytes()
{
var builder = new FlatBufferBuilder(1);
var paramName = builder.CreateString("ParagraphID"); // TODO здесь надо передавать результат выполнения операции
var paramVal = builder.CreateString(ParagraphID.ToString());
var parms = new Offset <Param> [1];
parms[0] = Param.CreateParam(builder, paramName, paramVal);
var paracol = Message.CreateParamsVector(builder, parms);
VectorOffset sentscol = default(VectorOffset);
sentscol = SentenceMap.BuildSentOffsetFromSentStructList(builder, this.sentlist);
Message.StartMessage(builder);
Message.AddMessType(builder, MessType.mReplay);
Message.AddServerType(builder, ServType.svSUBD);
Message.AddComtype(builder, command);
Message.AddParams(builder, paracol);
Message.AddSentences(builder, sentscol);
Message.AddDbID(builder, ParagraphID);
var req = Message.EndMessage(builder);
builder.Finish(req.Value);
return(builder.SizedByteArray());
}
internal override byte[] GenerateBytes()
{
var builder = new FlatBufferBuilder(1);
var signer = SignatureTransactionBuffer.CreatePublicKeyVector(builder, GetSigner());
var hash = SignatureTransactionBuffer.CreateHashVector(builder, OtherHash.FromHex());
var address = SignatureTransactionBuffer.CreateMultisigAddressVector(builder, Encoding.UTF8.GetBytes(MultisigAddress.Plain));
SignatureTransactionBuffer.StartSignatureTransactionBuffer(builder);
SignatureTransactionBuffer.AddTransactionType(builder, TransactionType.GetValue());
SignatureTransactionBuffer.AddVersion(builder, BitConverter.ToInt16(new byte[] { ExtractVersion(Version), 0 }, 0));
SignatureTransactionBuffer.AddNetwork(builder, BitConverter.ToInt16(new byte[] { 0, NetworkType.GetNetwork() }, 0));
SignatureTransactionBuffer.AddTimestamp(builder, NetworkTime.EpochTimeInMilliSeconds());
SignatureTransactionBuffer.AddPublicKeyLen(builder, 32);
SignatureTransactionBuffer.AddPublicKey(builder, signer);
SignatureTransactionBuffer.AddFee(builder, Fee);
SignatureTransactionBuffer.AddDeadline(builder, Deadline.Ticks);
SignatureTransactionBuffer.AddHashObjLength(builder, 0x24);
SignatureTransactionBuffer.AddSha3HashLength(builder, 0x20);
SignatureTransactionBuffer.AddHash(builder, hash);
SignatureTransactionBuffer.AddAddressLength(builder, 0x28);
SignatureTransactionBuffer.AddMultisigAddress(builder, address);
var result = SignatureTransactionBuffer.EndSignatureTransactionBuffer(builder);
builder.Finish(result.Value);
return(new SignatureTransactionSchema().Serialize(builder.SizedByteArray()));
}
public static byte[] NewVehicle(int vehicleId)
{
var builder = new FlatBufferBuilder(4);
FVehicle.StartFVehicle(builder);
switch (vehicleId)
{
case 0:
FVehicle.AddVehicleType(builder, FVehicleType.Pedestrian);
break;
case 1:
FVehicle.AddVehicleType(builder, FVehicleType.Cyclist);
break;
case 2:
default:
FVehicle.AddVehicleType(builder, FVehicleType.Car);
break;
}
FVehicle.AddVelocity(builder, 1);
var vehicleObj = FVehicle.EndFVehicle(builder);
builder.Finish(vehicleObj.Value);
return(builder.SizedByteArray());
}
void CreatefIG_Effect(int playerID, Vector3 pos, string EftName)
{
FlatBufferBuilder fbb = new FlatBufferBuilder(1);
fbb.Finish(fIG_Effect.CreatefIG_Effect(fbb, Class.fIG_Effect, playerID, pos.x, pos.y, pos.z, fbb.CreateString(EftName)).Value);
TCPClient.Instance.Send(fbb.SizedByteArray());
}
IEnumerator sending()
{
//이동할때 발생하는 코루틴
while (true)
{
Debug.Log("courutin continue");
// var idobj = GameObject.Find("connserver").GetComponent<connectserver>();
Vector3 destination_rot = new Vector3(0, 0, yrot);
Vector3 destination = player.position + (destination_rot * 0.1f * Time.deltaTime);
float destinationpos_x = destination.x;
float destinationpos_y = destination.y;
float destinationpos_z = destination.z;
float playerpos_x = player.position.x;
float playerpos_y = player.position.y;
float playerpos_z = player.position.z;
builder = new FlatBufferBuilder(1024);
var idoffset = builder.CreateString(PlayerPrefs.GetString("id"));
var nicknameoffset = builder.CreateString(PlayerPrefs.GetString("nickname"));
Player.StartPlayer(builder);
Player.AddStartstate(builder, PlayerStart.Play);
Player.AddUserindex(builder, PlayerPrefs.GetInt("userindex"));
Player.AddId(builder, idoffset);
Player.AddNickname(builder, nicknameoffset);
Player.AddPlayerpos(builder, Vec3.CreateVec3(builder, playerpos_x, playerpos_y, playerpos_z));
Player.AddPlayerrot(builder, yrot);
Player.AddMovestate(builder, MoveState.Move);
Player.AddDestinationpos(builder, Vec3.CreateVec3(builder, destinationpos_x, destinationpos_y, destinationpos_z));
Player.AddRoomindex(builder, playerinfo.playerindex);
Player.AddAttacked(builder, 0);
Player.AddFire(builder, 0);
Player.AddSkillfire(builder, 0);
Offset <Player> pypplayer = Player.EndPlayer(builder);
Game.StartGame(builder);
Game.AddPlayer(builder, pypplayer);
Game.AddTablenum(builder, 0);
Offset <Game> game = Game.EndGame(builder);
builder.Finish(game.Value);
sendBuffer = builder.SizedByteArray();
sendbb = new ByteBuffer(sendBuffer);
Debug.Log("Client send ");
if (findteam.stream.CanWrite)
{
findteam.stream.Write(sendBuffer, 0, sendBuffer.Length);
findteam.stream.Flush();
}
//1프레임마다 데이터 전송
yield return(new WaitForSeconds(0.1f));
}
}
/// <summary>
/// Generates the bytes.
/// </summary>
/// <returns>System.Byte[].</returns>
internal override byte[] GenerateBytes()
{
var builder = new FlatBufferBuilder(1);
// create vectors
var signatureVector = MosaicSupplyChangeTransactionBuffer.CreateSignatureVector(builder, new byte[64]);
var signerVector = MosaicSupplyChangeTransactionBuffer.CreateSignerVector(builder, GetSigner());
var feeVector = MosaicSupplyChangeTransactionBuffer.CreateFeeVector(builder, Fee.ToUInt8Array());
var deadlineVector = MosaicSupplyChangeTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array());
var mosaicIdVector = MosaicSupplyChangeTransactionBuffer.CreateMosaicIdVector(builder, MosaicId.Id.ToUInt8Array());
var deltaVector = MosaicSupplyChangeTransactionBuffer.CreateFeeVector(builder, Delta.ToUInt8Array());
ushort version = ushort.Parse(NetworkType.GetNetworkByte().ToString("X") + "0" + Version.ToString("X"), System.Globalization.NumberStyles.HexNumber);
// add vectors to buffer
MosaicSupplyChangeTransactionBuffer.StartMosaicSupplyChangeTransactionBuffer(builder);
MosaicSupplyChangeTransactionBuffer.AddSize(builder, 137);
MosaicSupplyChangeTransactionBuffer.AddSignature(builder, signatureVector);
MosaicSupplyChangeTransactionBuffer.AddSigner(builder, signerVector);
MosaicSupplyChangeTransactionBuffer.AddVersion(builder, version);
MosaicSupplyChangeTransactionBuffer.AddType(builder, TransactionTypes.Types.MosaicSupplyChange.GetValue());
MosaicSupplyChangeTransactionBuffer.AddFee(builder, feeVector);
MosaicSupplyChangeTransactionBuffer.AddDeadline(builder, deadlineVector);
MosaicSupplyChangeTransactionBuffer.AddMosaicId(builder, mosaicIdVector);
MosaicSupplyChangeTransactionBuffer.AddDirection(builder, SupplyType.GetValue());
MosaicSupplyChangeTransactionBuffer.AddDelta(builder, deltaVector);
// end build
var codedTransfer = TransferTransactionBuffer.EndTransferTransactionBuffer(builder);
builder.Finish(codedTransfer.Value);
return(new MosaicSupplyChangeTransactionSchema().Serialize(builder.SizedByteArray()));
}
public static void AcquireItems(int itemCode, int count)
{
var fbb = new FlatBufferBuilder(1);
fbb.Finish(fItem.CreatefItem(fbb, Class.fItem, itemCode, fbb.CreateString(""), -1, 0, 0, 0, 0, 0, 0, 0, 0, count).Value);
TCPClient.Instance.Send(fbb.SizedByteArray());
}
private byte[] Save()
{
Debug.Log("Creating and saving a Monster to byte array");
// Create a `FlatBufferBuilder`, which will be used to create our
// monsters' FlatBuffers.
var builder = new FlatBufferBuilder(1024);
var weaponOneName = builder.CreateString("Sword");
var weaponOneDamage = 3;
var weaponTwoName = builder.CreateString("Axe");
var weaponTwoDamage = 5;
// Use the `CreateWeapon()` helper function to create the weapons, since we set every field.
var sword = Weapon.CreateWeapon(builder, weaponOneName, (short)weaponOneDamage);
var axe = Weapon.CreateWeapon(builder, weaponTwoName, (short)weaponTwoDamage);
// Serialize a name for our monster, called "Orc".
var name = builder.CreateString("Orc");
// Create a `vector` representing the inventory of the Orc. Each number
// could correspond to an item that can be claimed after he is slain.
// Note: Since we prepend the bytes, this loop iterates in reverse order.
Monster.StartInventoryVector(builder, 10);
for (int i = 9; i >= 0; i--)
{
builder.AddByte((byte)i);
}
var inv = builder.EndVector();
var weaps = new Offset <Weapon> [2];
weaps[0] = sword;
weaps[1] = axe;
// Pass the `weaps` array into the `CreateWeaponsVector()` method to create a FlatBuffer vector.
var weapons = Monster.CreateWeaponsVector(builder, weaps);
Monster.StartPathVector(builder, 2);
Vec3.CreateVec3(builder, 1.0f, 2.0f, 3.0f);
Vec3.CreateVec3(builder, 4.0f, 5.0f, 6.0f);
var path = builder.EndVector();
// Create our monster using `StartMonster()` and `EndMonster()`.
Monster.StartMonster(builder);
Monster.AddPos(builder, Vec3.CreateVec3(builder, 1.0f, 2.0f, 3.0f));
Monster.AddHp(builder, 300);
Monster.AddName(builder, name);
Monster.AddInventory(builder, inv);
Monster.AddColor(builder, MyGame.Sample.Color.Red);
Monster.AddWeapons(builder, weapons);
Monster.AddEquippedType(builder, Equipment.Weapon);
Monster.AddEquipped(builder, axe.Value); // Axe
Monster.AddPath(builder, path);
var orc = Monster.EndMonster(builder);
// Call `Finish()` to instruct the builder that this monster is complete.
builder.Finish(orc.Value); // You could also call `Monster.FinishMonsterBuffer(builder, orc);`.
return(builder.SizedByteArray());
}
internal override byte[] GenerateBytes()
{
var builder = new FlatBufferBuilder(1);
// create vectors
var mosaicidVector = Buffers.MosaicLevy.CreateMosaicIdVector(builder, LevyInfo.Mosaic.Id.ToUInt8Array());
var levyFeeVector = Buffers.MosaicLevy.CreateFeeVector(builder, LevyInfo.Amount.ToUInt8Array());
var levyRecipentVector = Buffers.MosaicLevy.CreateRecipientVector(builder, LevyInfo.Recipent.GetBytes());
Buffers.MosaicLevy.StartMosaicLevy(builder);
Buffers.MosaicLevy.AddFee(builder, levyFeeVector);
Buffers.MosaicLevy.AddMosaicId(builder, mosaicidVector);
Buffers.MosaicLevy.AddRecipient(builder, levyRecipentVector);
Buffers.MosaicLevy.AddType(builder, LevyInfo.Levytype.GetValueInByte());
var Mosaic = Buffers.MosaicLevy.EndMosaicLevy(builder);
// create vectors
var signatureVector = ModifyMosaicLevyTransactionBuffer.CreateSignatureVector(builder, new byte[64]);
var signerVector = ModifyMosaicLevyTransactionBuffer.CreateSignerVector(builder, GetSigner());
var feeVector = ModifyMosaicLevyTransactionBuffer.CreateMaxFeeVector(builder, MaxFee?.ToUInt8Array());
var deadlineVector =
ModifyMosaicLevyTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array());
var mosaicIdVector =
ModifyMosaicLevyTransactionBuffer.CreateMosaicIdVector(builder, MosaicId.Id.ToUInt8Array());
// add size of the transaction
int totalSize = GetSerializedSize();
// create version
var version = GetTxVersionSerialization();
// add vectors to buffer
ModifyMosaicLevyTransactionBuffer.StartModifyMosaicLevyTransactionBuffer(builder);
ModifyMosaicLevyTransactionBuffer.AddSize(builder, (uint)totalSize);
ModifyMosaicLevyTransactionBuffer.AddSignature(builder, signatureVector);
ModifyMosaicLevyTransactionBuffer.AddSigner(builder, signerVector);
ModifyMosaicLevyTransactionBuffer.AddVersion(builder, (uint)version);
ModifyMosaicLevyTransactionBuffer.AddType(builder, TransactionType.GetValue());
ModifyMosaicLevyTransactionBuffer.AddMaxFee(builder, feeVector);
ModifyMosaicLevyTransactionBuffer.AddDeadline(builder, deadlineVector);
ModifyMosaicLevyTransactionBuffer.AddLevy(builder, Mosaic);
ModifyMosaicLevyTransactionBuffer.AddMosaicId(builder, mosaicIdVector);
// Calculate size
var codedTransaction = ModifyMosaicLevyTransactionBuffer.EndModifyMosaicLevyTransactionBuffer(builder);
builder.Finish(codedTransaction.Value);
var output = new ModifyMosaicLevyTransactionSchema().Serialize(builder.SizedByteArray());
if (output.Length != totalSize)
{
throw new SerializationException("Serialized form has incorrect length");
}
return(output);
}
public void TestNestedFlatBuffer()
{
const string nestedMonsterName = "NestedMonsterName";
const short nestedMonsterHp = 600;
const short nestedMonsterMana = 1024;
// Create nested buffer as a Monster type
var fbb1 = new FlatBufferBuilder(16);
var str1 = fbb1.CreateString(nestedMonsterName);
Monster.StartMonster(fbb1);
Monster.AddName(fbb1, str1);
Monster.AddHp(fbb1, nestedMonsterHp);
Monster.AddMana(fbb1, nestedMonsterMana);
var monster1 = Monster.EndMonster(fbb1);
Monster.FinishMonsterBuffer(fbb1, monster1);
var fbb1Bytes = fbb1.SizedByteArray();
fbb1 = null;
// Create a Monster which has the first buffer as a nested buffer
var fbb2 = new FlatBufferBuilder(16);
var str2 = fbb2.CreateString("My Monster");
var nestedBuffer = Monster.CreateTestnestedflatbufferVector(fbb2, fbb1Bytes);
Monster.StartMonster(fbb2);
Monster.AddName(fbb2, str2);
Monster.AddHp(fbb2, 50);
Monster.AddMana(fbb2, 32);
Monster.AddTestnestedflatbuffer(fbb2, nestedBuffer);
var monster = Monster.EndMonster(fbb2);
Monster.FinishMonsterBuffer(fbb2, monster);
// Now test the data extracted from the nested buffer
var mons = Monster.GetRootAsMonster(fbb2.DataBuffer);
var nestedMonster = mons.TestnestedflatbufferAsMonster();
Assert.AreEqual(nestedMonsterMana, nestedMonster.Mana);
Assert.AreEqual(nestedMonsterHp, nestedMonster.Hp);
Assert.AreEqual(nestedMonsterName, nestedMonster.Name);
}
