public static void BuildContent(ReportData client, OpenXmlPartContainer container, BlockItem block, string blockName, Dictionary <string, string> options) { TextBlock instance = BlockHelper.GetAssociatedBlockInstance <TextBlock>(blockName); if (null == instance) { return; } LogHelper.Instance.LogDebugFormat("Start TextBlock generation : Type {0}", blockName); Stopwatch treatmentWatch = Stopwatch.StartNew(); string content = instance.Content(client, options); ApplyContent(client, container, block, content); treatmentWatch.Stop(); LogHelper.Instance.LogDebugFormat ("End TextBlock generation ({0}) in {1} ms" , blockName , treatmentWatch.ElapsedMilliseconds.ToString() ); }
public void Append(Message message) { if (_stream == null) { throw new ObjectDisposedException("LogWriter"); } if (message.Time != _time) { BlockHelper.WriteBlock(_stream, BlockType.Timestamp, new ArraySegment <byte>(LogHelper.DateTimeToBytes(message.Time))); _time = message.Time; } var blockType = message.Direction == MessageDirection.ClientToServer ? BlockType.Client : BlockType.Server; BlockHelper.WriteBlock(_stream, blockType, message.Data); _stream.Flush(); }
/// <summary> /// Sets a single block into location specified /// </summary> /// <param name="inChunkPosition"></param> /// <param name="blockValue"></param> /// <param name="tag"></param> /// <param name="sourceDynamicId">Id of the entity that is responsible for the change</param> public override void SetBlock(Vector3I inChunkPosition, byte blockValue, BlockTag tag = null, uint sourceDynamicId = 0) { int index = ChunkCubes.Index(inChunkPosition.X + DataProviderUser.ChunkPositionBlockUnit.X, inChunkPosition.Y, inChunkPosition.Z + DataProviderUser.ChunkPositionBlockUnit.Y); ChunkCubes.Cubes[index] = new TerraCube(blockValue); SetTag(tag, inChunkPosition); RefreshMetaData(BlockHelper.ConvertToGlobal(new Vector3I(DataProviderUser.ChunkPositionBlockUnit.X, 0, DataProviderUser.ChunkPositionBlockUnit.Y), inChunkPosition), blockValue); OnBlockDataChanged(new ChunkDataProviderDataChangedEventArgs { Locations = new[] { inChunkPosition }, Bytes = new[] { blockValue }, Tags = tag != null ? new[] { tag } : null, SourceDynamicId = sourceDynamicId }); }
private List <SudokuCell> ApplyCandidate(SudokuCell cell, int value) { List <SudokuCell> result = new List <SudokuCell>(); for (int i = 0; i < BlockCount; i++) { // Check row var reducedCell = new SudokuCell(cell.X, i); if (i != cell.Y && _cellCandidatesDictionary.ContainsKey(reducedCell) && _cellCandidatesDictionary[reducedCell].Remove(value)) { result.Add(reducedCell); } // Check column reducedCell = new SudokuCell(i, cell.Y); if (i != cell.X && _cellCandidatesDictionary.ContainsKey(reducedCell) && _cellCandidatesDictionary[reducedCell].Remove(value)) { result.Add(reducedCell); } } int xStartPosition = BlockHelper.GetBlockStartPosition(cell.X, BlockRowCount); int xEndPosition = BlockHelper.GetBlockEndPosition(cell.X, BlockRowCount); int yStartPosition = BlockHelper.GetBlockStartPosition(cell.Y, BlockRowCount); int yEndPosition = BlockHelper.GetBlockEndPosition(cell.Y, BlockRowCount); // Check sector for (int i = xStartPosition; i < xEndPosition; i++) { for (int j = yStartPosition; j < yEndPosition; j++) { var reducedCell = new SudokuCell(i, j); if (!(i == cell.X || j == cell.Y) && _cellCandidatesDictionary.ContainsKey(reducedCell) && _cellCandidatesDictionary[reducedCell].Remove(value)) { result.Add(reducedCell); } } } return(result); }
private Tuple <Procedure, Implementation> GetCheckerTuple( List <Requires> requires, List <Variable> locals, List <Cmd> cmds, string suffix = "") { var proc = DeclHelper.Procedure( civlTypeChecker.AddNamePrefix($"IS_{checkName}_{inputAction.proc.Name}{suffix}"), invariantAction.impl.InParams, invariantAction.impl.OutParams, requires, modifies, new List <Ensures>()); var impl = DeclHelper.Implementation( proc, proc.InParams, proc.OutParams, locals, new List <Block> { BlockHelper.Block(checkName, cmds) }); return(Tuple.Create(proc, impl)); }
public static void ExportCrosses() { Database database = HostApplicationServices.WorkingDatabase; Editor editor = Autodesk.AutoCAD.ApplicationServices.Core.Application.DocumentManager.MdiActiveDocument.Editor; using (Transaction transaction = database.TransactionManager.StartTransaction()) { ObjectId[] blockReferenceIdCollection = BlockHelper.PromptForBlockSelection(editor, "Изберете координатни кръстове: "); if (blockReferenceIdCollection == null) { editor.WriteMessage("\nНевалидна селекция"); return; } StringBuilder output = new StringBuilder(); foreach (ObjectId blockReferenceId in blockReferenceIdCollection) { BlockReference blockReference = (BlockReference)transaction.GetObject(blockReferenceId, OpenMode.ForWrite); if (blockReference.Name != Cross.BlockName) { continue; } output.AppendFormat("{0} {1}{2}", blockReference.Position.X, blockReference.Position.Y, Environment.NewLine); } SaveFileDialog saveFileDialog = new SaveFileDialog(); saveFileDialog.Filter = "Text Files (*.txt)|*.txt|All files (*.*)|*.*"; if (saveFileDialog.ShowDialog() == DialogResult.OK) { File.WriteAllText(saveFileDialog.FileName, output.ToString()); } transaction.Commit(); } }
public static async Task ProcessLitigationCompleted(MySqlConnection connection, int blockchainID, Web3 cl, EventLog <List <ParameterOutput> > eventLog, EthApiService eth) { if (OTContract_Litigation_LitigationCompleted.TransactionExists(connection, eventLog.Log.TransactionHash, blockchainID)) { return; } var block = await BlockHelper.GetBlock(connection, eventLog.Log.BlockHash, eventLog.Log.BlockNumber, cl, blockchainID); var offerId = HexHelper.ByteArrayToString((byte[])eventLog.Event .First(e => e.Parameter.Name == "offerId").Result); var holderIdentity = (string)eventLog.Event .First(e => e.Parameter.Name == "holderIdentity").Result; var dhWasPenalized = (bool)eventLog.Event .First(e => e.Parameter.Name == "DH_was_penalized").Result; var transaction = await eth.Transactions.GetTransactionByHash.SendRequestAsync(eventLog.Log.TransactionHash); var receipt = await eth.Transactions.GetTransactionReceipt.SendRequestAsync(eventLog.Log.TransactionHash); var row = new OTContract_Litigation_LitigationCompleted() { TransactionHash = eventLog.Log.TransactionHash, BlockNumber = (UInt64)eventLog.Log.BlockNumber.Value, Timestamp = block.Timestamp, OfferId = offerId, HolderIdentity = holderIdentity, DHWasPenalized = dhWasPenalized, GasPrice = (UInt64)transaction.GasPrice.Value, GasUsed = (UInt64)receipt.GasUsed.Value, BlockchainID = blockchainID }; await OTContract_Litigation_LitigationCompleted.InsertIfNotExist(connection, row); }
public static void BuildContent(ReportData client, OpenXmlPartContainer container, BlockItem block, string blockName, Dictionary <string, string> options) { TableBlock instance = BlockHelper.GetAssociatedBlockInstance <TableBlock>(blockName); if (null != instance) { LogHelper.Instance.LogDebugFormat("Start TableBlock generation : Type {0}", blockName); Stopwatch treatmentWatch = Stopwatch.StartNew(); TableDefinition content = instance.Content(client, options); if (null != content) { ApplyContent(client, container, block, content, options); } treatmentWatch.Stop(); LogHelper.Instance.LogDebugFormat ("End TableBlock generation ({0}) in {1} millisecond{2}" , blockName , treatmentWatch.ElapsedMilliseconds.ToString() , treatmentWatch.ElapsedMilliseconds > 1 ? "s" : string.Empty ); } }
public async Task <Transaction> GenerateTransactionAsync(Address contractAddress, string methodName, IMessage input) { var blockchainService = Application.ServiceProvider.GetRequiredService <IBlockchainService>(); var refBlock = await blockchainService.GetBestChainLastBlockHeaderAsync(); var tx = new Transaction { From = Address.FromPublicKey(KeyPair.PublicKey), To = contractAddress, MethodName = methodName, Params = input.ToByteString(), RefBlockNumber = refBlock.Height, RefBlockPrefix = BlockHelper.GetRefBlockPrefix(refBlock.GetHash()) }; var signature = CryptoHelper.SignWithPrivateKey(KeyPair.PrivateKey, tx.GetHash().ToByteArray()); tx.Signature = ByteString.CopyFrom(signature); return(tx); }
public void UnpackDWordTest() { var rand = new Random(); uint[] b = new uint[2048]; byte[] buf = new byte[b.Length * 4]; for (var i = 0; i < b.Length; i++) { b[i] = (uint)rand.Next(int.MinValue, int.MaxValue); } for (var i = 0; i < buf.Length; i++) { buf[i] = (byte)((b[i / 4] >> ((i % 4) * 8)) & byte.MaxValue); } for (var i = 0; i < b.Length; i++) { Assert.IsTrue(BlockHelper.UnpackDWord(buf, i * 4) == b[i]); } }
public void UnpackQwordTest() { var rand = new Random(); ulong[] b = new ulong[2048]; byte[] buf = new byte[b.Length * 8]; for (var i = 0; i < b.Length; i++) { b[i] = (ulong)rand.Next(int.MinValue, int.MaxValue); } for (var i = 0; i < buf.Length; i++) { buf[i] = (byte)((b[i / 8] >> ((i % 8) * 8)) & byte.MaxValue); } for (var i = 0; i < b.Length; i++) { Assert.IsTrue(BlockHelper.UnpackQWord(buf, i * 8) == b[i]); } }
public void GetAssertiveAntennas() { if (this.AssertiveAntennaList.Count == 0) { this.AssertiveAntennaList = BlockHelper.GetGridAntennas(this.RemoteControl.SlimBlock.CubeGrid); if (this.AssertiveAntennaList.Count > 0) { for (int i = this.AssertiveAntennaList.Count - 1; i >= 0; i--) { var ant = this.AssertiveAntennaList[i]; if (ant?.SlimBlock == null) { this.AssertiveAntennaList.RemoveAt(i); continue; } if (ant.IsFunctional == false || ant.IsWorking == false || ant.IsBroadcasting == false) { this.AssertiveAntennaList.RemoveAt(i); continue; } if (this.AssertiveAntennaNames.Count > 0 && this.AssertiveAntennaNames.Contains(ant.CustomName) == false) { this.AssertiveAntennaList.RemoveAt(i); continue; } } if (this.AssertiveAntennaList.Count == 0) { this.UseAssertiveAntennas = false; return; } } } }
private void ReadHeader() { BlockType blockType; byte[] data; { // magic bytes BlockHelper.ReadBlock(_stream, out blockType, out data); if (blockType != BlockType.MagicBytes) { throw new FormatException("First block must be a MagicBytes block"); } if (!data.SequenceEqual(LogHelper.Encoding.GetBytes(LogHelper.MagicBytes))) { throw new FormatException("Incorrect magic bytes"); } } do { BlockHelper.ReadBlock(_stream, out blockType, out data); switch (blockType) { case BlockType.Start: break; case BlockType.Region: Header.Region = LogHelper.Encoding.GetString(data); break; case BlockType.MagicBytes: case BlockType.Timestamp: case BlockType.Server: case BlockType.Client: throw new FormatException($"Unexpected block type in header '{blockType}'"); } } while (blockType != BlockType.Start); }
public void ProcessCommandReceiveTriggerWatcher(string commandCode, IMyRemoteControl senderRemote, double radius, long entityId) { if (!_behavior.IsAIReady()) { return; } if (senderRemote?.SlimBlock?.CubeGrid == null || this.RemoteControl?.SlimBlock?.CubeGrid == null) { return; } var antenna = BlockHelper.GetActiveAntenna(this.AntennaList); if (antenna == null) { return; } if (Vector3D.Distance(this.RemoteControl.GetPosition(), senderRemote.GetPosition()) > radius) { return; } for (int i = 0; i < this.CommandTriggers.Count; i++) { var trigger = this.CommandTriggers[i]; if (trigger.UseTrigger == true && commandCode == trigger.CommandReceiveCode) { trigger.ActivateTrigger(); if (trigger.Triggered == true) { ProcessTrigger(trigger, entityId, true); } } } }
public void UnpackByteTest() { var rand = new Random(); byte[] b = new byte[2048]; byte[] buf = new byte[b.Length]; for (var i = 0; i < b.Length; i++) { b[i] = (byte)rand.Next(byte.MinValue, byte.MaxValue); } for (var i = 0; i < buf.Length; i++) { buf[i] = b[i]; } for (var i = 0; i < b.Length; i++) { Assert.IsTrue(BlockHelper.UnpackByte(buf, i) == b[i]); } }
public void UnpackWordTest() { var rand = new Random(); ushort[] b = new ushort[2048]; byte[] buf = new byte[b.Length * 2]; for (var i = 0; i < b.Length; i++) { b[i] = (ushort)rand.Next(ushort.MinValue, ushort.MaxValue); } for (var i = 0; i < buf.Length; i++) { buf[i] = (byte)((b[i / 2] >> ((i % 2) * 8)) & byte.MaxValue); } for (var i = 0; i < b.Length; i++) { Assert.IsTrue(BlockHelper.UnpackWord(buf, i * 2) == b[i]); } }
public void InitRandom(Int3 size, int mineCount) { this.size = size; this.totalMineCount = mineCount; this.remainMineCount = mineCount; List <Int3> posList = new List <Int3>(); map = new Dictionary <Int3, BlockType>(); BlockHelper.sizeForeach(size, (Int3 pos) => { posList.Add(pos); map.Add(pos, BlockType.Num0); }); for (int i = 0; i < mineCount; i++) { int idx = Random.Range(0, posList.Count); Int3 mineNow = posList[idx]; map[mineNow] = BlockType.Bomb; for (int j = 0; j < BlockHelper.SixDirections.Length; j++) { Int3 dir = BlockHelper.SixDirections[j]; Int3 pos = mineNow + dir; if (map.ContainsKey(pos)) { if (Block.IsNum(map[pos])) { map[pos] = (BlockType)(map[pos] + 1); } } } posList.RemoveAt(idx); } // map = new bool[size.x,size.y,size.z]; }
public void UnpackWStringTest() { var builder = new StringBuilder(); var rand = new Random(); string[] s = new string[99]; byte[] buf = new byte[2 * 4950 + 1]; // triangle number T(99) = 4950 var offset = 0; for (var i = 0; i < s.Length; i++) { for (var j = 0; j < i; j++) { builder.Append((char)rand.Next(char.MinValue + 1, char.MaxValue)); if (builder[builder.Length - 1] >= 0xD800 && builder[builder.Length - 1] <= 0xDFFF) { builder.Remove(builder.Length - 1, 1); j--; } } s[i] = builder.ToString(); builder.Clear(); Encoding.Unicode.GetBytes(s[i]).CopyTo(buf, offset); buf[offset + 2 * i] = 0x00; buf[offset + 2 * (i + 1)] = 0x00; offset += 2 * (i + 1); } offset = 0; for (var i = 0; i < s.Length; i++) { Assert.IsTrue(s[i].Length == i); Assert.IsTrue(BlockHelper.UnpackWString(buf, offset) == s[i]); offset += 2 * (s[i].Length + 1); } }
private IEnumerable <Declaration> PendingAsyncNoninterferenceCheckers() { if (CommandLineOptions.Clo.TrustNoninterference) { yield break; } HashSet <AtomicAction> pendingAsyncsToCheck = new HashSet <AtomicAction>( civlTypeChecker.procToAtomicAction.Values .Where(a => a.layerRange.Contains(layerNum) && a.HasPendingAsyncs) .SelectMany(a => a.pendingAsyncs)); foreach (var action in pendingAsyncsToCheck) { var inputs = action.impl.InParams; var outputs = action.impl.OutParams; var requires = action.gate.Select(a => new Requires(false, a.Expr)).ToList(); var ensures = new List <Ensures>(); var modifies = civlTypeChecker.GlobalVariables.Select(Expr.Ident).ToList(); var locals = globalSnapshotInstrumentation.NewLocalVars.Union(noninterferenceInstrumentation.NewLocalVars).ToList(); var cmds = new List <Cmd>(); cmds.AddRange(globalSnapshotInstrumentation.CreateInitCmds()); cmds.AddRange(noninterferenceInstrumentation.CreateInitCmds(action.impl)); cmds.Add(CmdHelper.CallCmd(action.proc, inputs, outputs)); cmds.AddRange(noninterferenceInstrumentation.CreateCallToYieldProc()); var blocks = new List <Block> { BlockHelper.Block("init", cmds) }; var name = civlTypeChecker.AddNamePrefix($"PendingAsyncNoninterferenceChecker_{action.proc.Name}_{layerNum}"); var proc = DeclHelper.Procedure(name, inputs, outputs, requires, modifies, ensures); var impl = DeclHelper.Implementation(proc, inputs, outputs, locals, blocks); yield return(proc); yield return(impl); } }
/// <summary> /// Finds the free blocks. /// </summary> /// <param name="hint">The hint.</param> /// <param name="strategy">The strategy.</param> /// <param name="count">The count.</param> /// <returns></returns> List <ulong> FindFreeBlocks(object op, ulong hint, AllocationStrategy strategy, uint count, List <AllocationBlockInfo> lockedBlocks) { // We load blocks in vicinity. If there is no hint, we chose one. if (hint == 0) { // We choose the "default" key. uint unused; // We must extract first allocation block, the only way is to use the enumerator. IEnumerator <KeyValuePair <ulong, AllocationBlockInfo> > en = inspectedFreeBlocks.GetEnumerator(); en.MoveNext(); hint = inspectedFreeBlocks.Count > 0 ? en.Current.Key : BlockHelper.GetAllocationBlock(provider.BlockSize, 1, out unused); } // TODO Super blocks. List <ulong> freeBlocks = new List <ulong>(); // We begin allocation (forward from hint) uint unused2; ulong block = BlockHelper.GetAllocationBlock(provider.BlockSize, hint, out unused2); for (; count > 0; block = BlockHelper.GetNextAllocationBlock(provider.BlockSize, block, blockCount)) { AddBlock(op, block, freeBlocks, lockedBlocks, ref count); } // And backwards if none found. for (block = BlockHelper.GetPrevAllocationBlock(provider.BlockSize, block); count > 0; block = BlockHelper.GetPrevAllocationBlock(provider.BlockSize, block)) { AddBlock(op, block, freeBlocks, lockedBlocks, ref count); } return(freeBlocks); }
private void PlayerDisplacementChunkEvents() { double distance = MVector3.Distance2D(_lastPlayerTriggeredPosition, PlayerManager.Player.Position); //Triggered when player has move a distance of 8 blocks (half chunk distance) if (distance > (AbstractChunk.ChunkSize.X / 2d)) { var newEventNotificationArea = new Range3I { Position = BlockHelper.EntityToChunkPosition(PlayerManager.Player.Position) - _eventNotificationArea.Size / 2, Size = _eventNotificationArea.Size }; var chunks2Syncro = newEventNotificationArea.AllExclude(_eventNotificationArea); if (chunks2Syncro != null) { bool synchroFullyRequested = true; //Get all new chunk in the area that are in a state ready to be requested ! //Check that the concerned chunks are in a correct state to be requested. foreach (var chunkPosition in chunks2Syncro) { if (ResyncChunk(chunkPosition, false) == false) { synchroFullyRequested = false; break; } } if (synchroFullyRequested) { _eventNotificationArea = newEventNotificationArea; } } _lastPlayerTriggeredPosition = PlayerManager.Player.Position; ChunkNeed2BeSorted = true; } }
public async Task WhenCreateFileSystemHeaderBlockThenBlockIsValid() { var pfs3AioBytes = await File.ReadAllBytesAsync(@"TestData\pfs3aio"); var fileSystemHeaderBlock = BlockHelper.CreateFileSystemHeaderBlock(FormatHelper.FormatDosType("PDS", 3), 19, 2, pfs3AioBytes); Assert.Equal(1245186U, fileSystemHeaderBlock.Version); var loadSegBlockCount = Math.Ceiling((double)pfs3AioBytes.Length / (512 - 5 * 4)); Assert.Equal(loadSegBlockCount, fileSystemHeaderBlock.LoadSegBlocks.Count()); var actualPfs3AioBytes = new List <byte>(); foreach (var loadSegBlock in fileSystemHeaderBlock.LoadSegBlocks) { actualPfs3AioBytes.AddRange(loadSegBlock.Data); } Assert.Equal(pfs3AioBytes.Length, actualPfs3AioBytes.Count); Assert.True(pfs3AioBytes.SequenceEqual(actualPfs3AioBytes)); }
/// <summary> /// /// </summary> /// <param name="client"></param> /// <param name="pPackage"></param> /// <param name="block"></param> /// <param name="blockName"></param> /// <param name="options"></param> public static void BuildContent(ReportData client, OpenXmlPackage pPackage, BlockItem block, string blockName, Dictionary <string, string> options) { var previousCulture = Thread.CurrentThread.CurrentCulture; Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; GraphBlock instance = BlockHelper.GetAssociatedBlockInstance <GraphBlock>(blockName); if (null == instance) { return; } LogHelper.Instance.LogDebugFormat("Start GraphBlock generation : Type {0}", blockName); Stopwatch treatmentWatch = Stopwatch.StartNew(); TableDefinition content = instance.Content(client, options); try { if (null != content) { ApplyContent(client, pPackage, block, content, options); } } finally { Thread.CurrentThread.CurrentCulture = previousCulture; treatmentWatch.Stop(); LogHelper.Instance.LogDebugFormat ("End GraphBlock generation ({0}) in {1} millisecond{2}" , blockName , treatmentWatch.ElapsedMilliseconds , treatmentWatch.ElapsedMilliseconds > 1 ? "s" : string.Empty ); } }
private void StartMining() { var block = NodeApi.Current.GenerateMiningBlock(_startArgs.Name, _startArgs.Account); var currentScoopNumber = POC.GetScoopNumber(block.Header.PayloadHash, block.Header.Height); _startTime = Time.EpochTime; block.Header.Timestamp = _startTime; if (block.Header.Height != this.currentBlockHeight || this.currentBlockStartTime <= 0) { this.currentBlockStartTime = _startTime; this.currentBlockHeight = block.Header.Height; } StartMiningMsg startMiningMsg = StartMiningMsg.CreateNew(); startMiningMsg.BlockHeight = block.Header.Height; startMiningMsg.ScoopNumber = currentScoopNumber; startMiningMsg.StartTime = _startTime; var genHash = BlockHelper.GenHash(block.Header.PayloadHash, block.Header.Height); startMiningMsg.GenHash = Base16.Encode(genHash); startMiningMsg.BaseTarget = NodeApi.Current.GetBaseTarget(block.Header.Height); var blockKey = KeyHelper.GetBlockKey(startMiningMsg.Id); RedisManager.Current.SaveDataToRedis(blockKey, block); //MQApi.SendStartMsg(startMiningMsg); RabbitMQApi.SendStartMsg(startMiningMsg); CurrentStartMiningMsg = startMiningMsg; LogHelper.Info("Start MiningTask Id=" + startMiningMsg.Id + " ScoopNumber = " + startMiningMsg.ScoopNumber + " Height= " + startMiningMsg.BlockHeight); LogHelper.Info($"Block bits is {POC.ConvertBitsToBigInt(block.Header.Bits).ToString("X").PadLeft(64, '0')}"); LogHelper.Info($"StartMiningMsg.BaseTarget is {POC.ConvertBitsToBigInt(startMiningMsg.BaseTarget).ToString("X").PadLeft(64, '0')}"); LogHelper.Info($"Block height is {block.Header.Height}"); }
void ChunkBlocksChanged(object sender, ChunkDataProviderDataChangedEventArgs e) { var chunk = (ServerChunk)sender; chunk.LastAccess = DateTime.Now; var globalPos = new Vector3I[e.Locations.Length]; e.Locations.CopyTo(globalPos, 0); BlockHelper.ConvertToGlobal(chunk.Position, globalPos); // tell entities about blocks change var eargs = new BlocksChangedEventArgs { ChunkPosition = chunk.Position, BlockValues = e.Bytes, Locations = e.Locations, GlobalLocations = globalPos, Tags = e.Tags, SourceEntityId = e.SourceDynamicId }; GetArea(new Vector3D(eargs.ChunkPosition.X * AbstractChunk.ChunkSize.X, 0, eargs.ChunkPosition.Z * AbstractChunk.ChunkSize.Z)).OnBlocksChanged(eargs); }
/// <summary> /// Creates an unsigned serialized transaction /// </summary> /// <param name="input"></param> /// <returns></returns> public async Task <CreateRawTransactionOutput> CreateRawTransactionAsync(CreateRawTransactionInput input) { var transaction = new Transaction { From = Address.FromBase58(input.From), To = Address.FromBase58(input.To), RefBlockNumber = input.RefBlockNumber, RefBlockPrefix = BlockHelper.GetRefBlockPrefix(Hash.LoadFromHex(input.RefBlockHash)), MethodName = input.MethodName }; var methodDescriptor = await GetContractMethodDescriptorAsync(Address.FromBase58(input.To), input.MethodName); if (methodDescriptor == null) { throw new UserFriendlyException(Error.Message[Error.NoMatchMethodInContractAddress], Error.NoMatchMethodInContractAddress.ToString()); } try { var parameters = methodDescriptor.InputType.Parser.ParseJson(input.Params); if (!IsValidMessage(parameters)) { throw new UserFriendlyException(Error.Message[Error.InvalidParams], Error.InvalidParams.ToString()); } transaction.Params = parameters.ToByteString(); } catch { throw new UserFriendlyException(Error.Message[Error.InvalidParams], Error.InvalidParams.ToString()); } return(new CreateRawTransactionOutput { RawTransaction = transaction.ToByteArray().ToHex() }); }
public Task <IEnumerable <Transaction> > GetPreTransactionsAsync(IReadOnlyList <ServiceDescriptor> descriptors, ITransactionContext transactionContext) { if (!descriptors.Any(service => service.File.Name == "test_basic_function_with_parallel_contract.proto")) { return(Task.FromResult(new List <Transaction>().AsEnumerable())); } if (transactionContext.Transaction.To == ParallelTestHelper.BasicFunctionWithParallelContractAddress && !transactionContext.Transaction.MethodName.EndsWith("Plugin")) { return(Task.FromResult(new List <Transaction>().AsEnumerable())); } var context = _contextService.Create(); context.TransactionContext = transactionContext; var transactions = new List <Transaction>(); switch (transactionContext.Transaction.MethodName) { case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.RemoveValueFromInlineWithPlugin): case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.RemoveValueFromPostPlugin): case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.RemoveValueWithPlugin): case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.RemoveValueParallelFromPostPlugin): { var input = RemoveValueInput.Parser.ParseFrom(transactionContext.Transaction.Params); transactions.Add(new Transaction { From = transactionContext.Transaction.From, To = ParallelTestHelper.BasicFunctionWithParallelContractAddress, Params = new IncreaseValueInput { Key = input.Key, Memo = Guid.NewGuid().ToString() }.ToByteString(), MethodName = nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValue), RefBlockNumber = transactionContext.BlockHeight - 1, RefBlockPrefix = BlockHelper.GetRefBlockPrefix(transactionContext.PreviousBlockHash) }); break; } case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.RemoveValueFromPrePlugin): { var input = RemoveValueInput.Parser.ParseFrom(transactionContext.Transaction.Params); transactions.Add(new Transaction { From = transactionContext.Transaction.From, To = ParallelTestHelper.BasicFunctionWithParallelContractAddress, Params = input.ToByteString(), MethodName = nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.RemoveValue), RefBlockNumber = transactionContext.BlockHeight - 1, RefBlockPrefix = BlockHelper.GetRefBlockPrefix(transactionContext.PreviousBlockHash) }); break; } case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValueWithPrePlugin): case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValueWithInlineAndPrePlugin): case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValueWithPlugin): case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValueWithInlineAndPlugin): case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValueParallelWithInlineAndPlugin): case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValueFailedWithPlugin): case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValueFailedWithPrePlugin): case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValueFailedWithInlineAndPlugin): case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValueFailedParallelWithInlineAndPlugin): case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValueFailedWithInlineAndPrePlugin): case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValueWithFailedInlineAndPlugin): case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValueWithFailedInlineAndPrePlugin): case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValueParallelWithFailedInlineAndPlugin): case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValueWithPrePluginAndFailedPostPlugin): case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValueWithInlineAndPrePluginAndFailedPostPlugin): { var input = IncreaseValueInput.Parser.ParseFrom(transactionContext.Transaction.Params); transactions.Add(new Transaction { From = transactionContext.Transaction.From, To = ParallelTestHelper.BasicFunctionWithParallelContractAddress, Params = new IncreaseValueInput { Key = input.Key, Memo = Guid.NewGuid().ToString() }.ToByteString(), MethodName = nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValue), RefBlockNumber = transactionContext.BlockHeight - 1, RefBlockPrefix = BlockHelper.GetRefBlockPrefix(transactionContext.PreviousBlockHash) }); break; } case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValueWithFailedPrePlugin): case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValueWithInlineAndFailedPrePlugin): case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValueWithFailedPrePluginAndPostPlugin): case nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValueWithInlineAndFailedPrePluginAndPostPlugin): { var input = IncreaseValueInput.Parser.ParseFrom(transactionContext.Transaction.Params); transactions.Add(new Transaction { From = transactionContext.Transaction.From, To = ParallelTestHelper.BasicFunctionWithParallelContractAddress, Params = new IncreaseValueInput { Key = input.Key, Memo = Guid.NewGuid().ToString() }.ToByteString(), MethodName = nameof(BasicFunctionWithParallelContractContainer.BasicFunctionWithParallelContractStub.IncreaseValueFailed), RefBlockNumber = transactionContext.BlockHeight - 1, RefBlockPrefix = BlockHelper.GetRefBlockPrefix(transactionContext.PreviousBlockHash) }); break; } } return(Task.FromResult(transactions.AsEnumerable())); }
public void DrawModels(Camera3D camera) { BlockMask maskAtCursor = ParentSegmentManager.GetBlockMaskAt(_keyboardCursor); switch (_selectedType) { case EditorType.Blocks: if (ParentSegmentManager.IsLocationObstructed(_keyboardCursor)) { _blockHighlightBlocked.Draw(ParentSegmentManager.Device, camera, _keyboardCursor.WorldLocation, Vector3.Zero, 0f, new Vector3(1, 1, 1)); } else { _blockHighlight.Draw(ParentSegmentManager.Device, camera, _keyboardCursor.WorldLocation, Vector3.Zero, 0f, new Vector3(1, 1, 1)); } break; case EditorType.BottomRamps: if (BlockHelper.HasTopRamp(maskAtCursor) && BlockHelper.GetRampBlockDirection(maskAtCursor) == _RampBlockDirection) { _blockHighlight.Draw(ParentSegmentManager.Device, camera, _keyboardCursor.WorldLocation, Vector3.Zero, 0f, new Vector3(1, 1, 1)); } else { if (ParentSegmentManager.IsLocationObstructed(_keyboardCursor)) { _blockHighlightBlocked.Draw(ParentSegmentManager.Device, camera, _keyboardCursor.WorldLocation, Vector3.Zero, 0f, new Vector3(1, 1, 1)); } else { _blockHighlight.Draw(ParentSegmentManager.Device, camera, _keyboardCursor.WorldLocation, Vector3.Zero, 0f, new Vector3(1, 1, 1)); } } break; case EditorType.TopRamps: if (BlockHelper.HasBottomRamp(maskAtCursor) && BlockHelper.GetRampBlockDirection(maskAtCursor) == _RampBlockDirection) { _blockHighlight.Draw(ParentSegmentManager.Device, camera, _keyboardCursor.WorldLocation, Vector3.Zero, 0f, new Vector3(1, 1, 1)); } else { if (ParentSegmentManager.IsLocationObstructed(_keyboardCursor)) { _blockHighlightBlocked.Draw(ParentSegmentManager.Device, camera, _keyboardCursor.WorldLocation, Vector3.Zero, 0f, new Vector3(1, 1, 1)); } else { _blockHighlight.Draw(ParentSegmentManager.Device, camera, _keyboardCursor.WorldLocation, Vector3.Zero, 0f, new Vector3(1, 1, 1)); } } break; default: _previewData = new BlockVertexData(); break; } }
public void HandleHighlight() { Vector3 newPosition = _keyboardCursor.WorldLocation; if (InputHelper.IsNewKeyPress(Keys.NumPad3)) { newPosition += WorldDirection.East; } if (InputHelper.IsNewKeyPress(Keys.NumPad1)) { newPosition += WorldDirection.North; } if (InputHelper.IsNewKeyPress(Keys.NumPad7)) { newPosition += WorldDirection.West; } if (InputHelper.IsNewKeyPress(Keys.NumPad9)) { newPosition += WorldDirection.South; } if (InputHelper.IsNewKeyPress(Keys.Add)) { newPosition += WorldDirection.Up; } if (InputHelper.IsNewKeyPress(Keys.Subtract)) { newPosition += WorldDirection.Down; } // Following is for valid block ranges only. if (ParentSegmentManager.GetBlockMaskAt(new SegmentLocation(newPosition)) != BlockHelper.BlockMasks.Null) { if (newPosition != _keyboardCursor.WorldLocation) { // check for an object? int segmentX = (int)Math.Floor((double)newPosition.X / WorldGlobal.SegmentSize.X); int segmentZ = (int)Math.Floor((double)newPosition.Z / WorldGlobal.SegmentSize.Z); //_ItemsUnderCursor = ParentSegmentManager.Segments[segmentX, segmentZ].Items.FindItemsAt(newPosition); } _keyboardCursor = new SegmentLocation(newPosition); if (InputHelper.IsNewKeyPress(Keys.Delete)) { ParentSegmentManager.SetBlockMaskAt(_keyboardCursor, BlockHelper.BlockMasks.Air); } if (InputHelper.IsNewKeyPress(Keys.Insert)) { BlockMask maskAtCursor = ParentSegmentManager.GetBlockMaskAt(_keyboardCursor); switch (_selectedType) { case EditorType.Blocks: ParentSegmentManager.SetBlockMaskAt(_keyboardCursor, _activeBlockMask); break; case EditorType.BottomRamps: if (BlockHelper.HasTopRamp(maskAtCursor) && BlockHelper.GetRampBlockDirection(maskAtCursor) == _RampBlockDirection) { ParentSegmentManager.SetBlockMaskAt(_keyboardCursor, maskAtCursor | _activeBlockMask); } else { ParentSegmentManager.SetBlockMaskAt(_keyboardCursor, _activeBlockMask); } break; case EditorType.TopRamps: if (BlockHelper.HasBottomRamp(maskAtCursor) && BlockHelper.GetRampBlockDirection(maskAtCursor) == _RampBlockDirection) { ParentSegmentManager.SetBlockMaskAt(_keyboardCursor, maskAtCursor | _activeBlockMask); } else { ParentSegmentManager.SetBlockMaskAt(_keyboardCursor, _activeBlockMask); } break; default: _previewData = new BlockVertexData(); break; } } } else { DebugLog.Log("Can't move World Cursor to (" + newPosition.X + ", " + newPosition.Y + ", " + newPosition.Z + ") - Out of bounds", DebugMessageType.Warning); } }
public static void DrawCrosses() { Database database = HostApplicationServices.WorkingDatabase; Editor editor = Autodesk.AutoCAD.ApplicationServices.Core.Application.DocumentManager.MdiActiveDocument.Editor; string mapGridCrossFilePath = string.Format("{0}{1}Resources{1}Map_Grid_Cross.dwg", Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), Path.DirectorySeparatorChar); BlockHelper.CopyBlockFromDwg(Cross.BlockName, mapGridCrossFilePath, database); PromptIntegerOptions promptScaleOptions = new PromptIntegerOptions("\nВъведете мащаб: ") { DefaultValue = 1000, AllowNegative = false, AllowZero = false, UseDefaultValue = true, AllowNone = false }; PromptIntegerResult promptScaleResult = editor.GetInteger(promptScaleOptions); if (promptScaleResult.Status != PromptStatus.OK) { editor.WriteMessage("\nНевалиден мащаб"); return; } int scale = promptScaleResult.Value; PromptPointOptions promptLowerLeftPointOptions = new PromptPointOptions("\nИзберете долен ляв ъгъл на картата: "); PromptPointResult promptLowerLeftPointResult = editor.GetPoint(promptLowerLeftPointOptions); if (promptLowerLeftPointResult.Status != PromptStatus.OK) { editor.WriteMessage("\nНевалидна точка"); return; } Point3d lowerLeftPoint = promptLowerLeftPointResult.Value; PromptPointOptions promptUpperRightPointOptions = new PromptPointOptions("\nИзберете горен десен ъгъл на картата: "); PromptPointResult promptUpperRightPointResult = editor.GetPoint(promptUpperRightPointOptions); if (promptUpperRightPointResult.Status != PromptStatus.OK) { editor.WriteMessage("\nНевалидна точка"); return; } Point3d upperRightPoint = promptUpperRightPointResult.Value; if (upperRightPoint.X <= lowerLeftPoint.X || upperRightPoint.Y <= lowerLeftPoint.Y) { editor.WriteMessage("\nНевалидни точки"); return; } var crosses = MapGrid.GenerateCrosses(new BoundaryPoint(lowerLeftPoint.X, lowerLeftPoint.Y), new BoundaryPoint(upperRightPoint.X, upperRightPoint.Y), scale); using (Transaction transaction = database.TransactionManager.StartTransaction()) { BlockTable blockTable = database.BlockTableId.GetObject(OpenMode.ForRead) as BlockTable; BlockTableRecord blockDefinition = blockTable[Cross.BlockName].GetObject(OpenMode.ForWrite) as BlockTableRecord; BlockTableRecord modelSpaceBlockTableRecord = blockTable[BlockTableRecord.ModelSpace].GetObject(OpenMode.ForWrite) as BlockTableRecord; foreach (var cross in crosses) { Point3d blockReferenceInsertPoint = new Point3d(cross.X, cross.Y, 0); using (BlockReference blockReference = new BlockReference(blockReferenceInsertPoint, blockDefinition.ObjectId)) { blockReference.ScaleFactors = new Scale3d(scale / 1000.0); modelSpaceBlockTableRecord.AppendEntity(blockReference); transaction.AddNewlyCreatedDBObject(blockReference, true); } } transaction.Commit(); } }
public void MoveCameraToBlock(BlockHelper block) { if (block != null) { // /|<-----a is this angle // HY/ |AJ // / | // / | // / | // /_____| // OP float cosOfCam = Mathf.Cos( (90 - myTransform.eulerAngles.x) * Mathf.Deg2Rad); //COS of a. not sure why, but when we have the A angle in editor set to 55, its actually 35. I think it measures from the top float heightOfCamAboveBlock = myTransform.position.y - block.myTransform.position.y; //calculate AJ float hypotenuse = heightOfCamAboveBlock / cosOfCam; //calculates HY float newLength = Mathf.Sqrt(Mathf.Pow(hypotenuse, 2) - Mathf.Pow(heightOfCamAboveBlock, 2)); //calculates OP. See pythagoras theorum myTransform.position = new Vector3(block.myTransform.position.x, myTransform.position.y, block.myTransform.position.z - newLength); //move camera to new position } }