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); }