public CreateReferenceDlgViewModel(IBlockManager blockManager, TreeItemDto first)
{
_blockManager = blockManager;
Block1 = new NamedGuid() {Caption = first.Caption, Uid = first.Id};
IsTo = true;
SelectBlockCommand = new DelegateCommand(() =>
{
var dlg = new SelectTagDlg(typeof(Block));
var res = dlg.ShowDialog();
if (res.HasValue && res.Value && dlg.Id.HasValue)
{
var block = _blockManager.GetBlockById(dlg.Id.Value);
Block2 = new NamedGuid() {Caption = block.Caption, Uid = block.Id};
OnPropertyChanged("Block2");
OkCommand.RaiseCanExecuteChanged();
}
});
OkCommand = new DelegateCommand<Window>(window =>
{
window.DialogResult = true;
window.Close();
}, window => Block2 != null);
}
public AddParticleDlgViewModel(IParticlesManager particleManager, Type targetType, IBlockManager blockManager)
{
_particleManager = particleManager;
_blockManager = blockManager;
AddParticleVm = new AddParticleViewViewModel(_particleManager, Visibility.Collapsed);
OkCommand = new DelegateCommand<Window>((wnd) =>
{
if (AddParticleVm.UseNewParticle)
{
var particle = _particleManager.CreateParticle(AddParticleVm.NewParticle.Material,
AddParticleVm.NewParticle.Begin, AddParticleVm.NewParticle.End);
_blockManager.AddParticleToBlock(_block, particle);
}
else if (AddParticleVm.UseExistParticle && AddParticleVm.ExistParticle.HasValue)
{
var particle = _particleManager.GetParticleById(AddParticleVm.ExistParticle.Value);
_blockManager.AddParticleToBlock(_block, particle);
}
wnd.DialogResult = true;
wnd.Close();
}, wnd => _block != null && (AddParticleVm.UseNewParticle || AddParticleVm.UseExistParticle));
SelectIdeaCommand = new DelegateCommand(() =>
{
var dlg = new SelectTagDlg(targetType);
var res = dlg.ShowDialog();
if (res.HasValue && res.Value && dlg.Id.HasValue)
{
_block = _blockManager.GetBlockById(dlg.Id.Value);
BlockCaption = _block.Caption;
OkCommand.RaiseCanExecuteChanged();
}
});
}
public ParticlePropertiesViewModel(IEventAggregator eventAggregator,
IParticlesManager particlesManager, IBlockManager blockManager)
{
_particleGuid = Guid.Empty;
_eventAggregator = eventAggregator;
_particlesManager = particlesManager;
_blockManager = blockManager;
ParticleInplaces = new ObservableCollection<ParticleInplaceBlock>();
_eventAggregator.GetEvent<BookmarkSelected>().Subscribe(BookmarkSelected);
DeleteParticleInplaceCommand = new DelegateCommand<ParticleInplaceBlock>(pi =>
{
_particlesManager.DeleteParticleInplace(pi.ParticleInplace);
ParticleInplaces.Remove(pi);
});
DeleteParticleCommand = new DelegateCommand(() =>
{
if (_particleGuid != Guid.Empty)
{
var result = _particlesManager.DeleteParticle(_particleGuid);
if (result)
{
_eventAggregator.GetEvent<MaterialUpdatedEvent>().Publish(_materialId);
_eventAggregator.GetEvent<BookmarkSelected>().Publish(Guid.Empty);
}
}
});
}
public unsafe void CreateSpace(uint blockCount = 24, uint blockSize = DefaultBlockSize)
{
Space = InstantiateSpace(blockCount, blockSize);
RawBlockManager.DebugBackdrop((byte*) Space.Pointer,(uint) Space.Capacity);
RawBlockManager.Initialize(Space, BlockCount = blockCount,BlockSize = blockSize);
BlockManager = SingleInstanceRawBlockManager.Create(Space);
}
public TagsManagerMainView(ITagsManager tagsManager, TagsManagerMainViewModel model,
IIdeaManager ideaManager, IRelationManager relationManager, IBlockManager blockManager, IMaterialManager materialManager)
{
_relationManager = relationManager;
_blockManager = blockManager;
var db = new AllDb()
{
RelationManager = _relationManager,
IdeaManager = ideaManager,
BlockManager = _blockManager,
TagsManager = tagsManager,
MaterialManager = materialManager
};
InitializeComponent();
_tagHelper = new TagTreeHelper(treeList, db);
_tagHelper.ReloadTree();
model.NodeAdded += dto =>
{
dto.AddNodeToTree(treeList);
treeList.CurrentItem = dto;
};
model.NodeAnnihilated += dto => dto.AnnihilateNode(treeList);
model.MaterialUpdate += dto => dto.UpdateMaterialInTree(treeList);
Loaded += (sender, args) =>
{
DataContext = model;
treeList.View.ValidateCell += (o, e) =>
{
var wrong = Path.GetInvalidFileNameChars();
if (e.Value.ToString().Any(wrong.Contains))
e.IsValid = false;
};
treeList.View.PreviewKeyDown += (o, eventArgs) =>
{
if (eventArgs.Key == Key.Enter || eventArgs.Key == Key.Return)
{
eventArgs.Handled = true;
treeList.View.CloseEditor();
RenameCurrent();
}
};
treeList.View.ShownEditor += ViewOnShownEditor;
model.RenameTag += dto => Dispatcher.Invoke(() =>
{
treeList.View.AllowEditing = true;
treeList.View.ShowEditor(true);
}, DispatcherPriority.Background);
model.Refresh += () => Dispatcher.Invoke(() => _tagHelper.ReloadTree(),
DispatcherPriority.Background);
};
}
public JsApi(string worldDirectory)
{
if (!Directory.Exists(worldDirectory))
Directory.CreateDirectory(worldDirectory);
this.world = AnvilWorld.Create(worldDirectory);
this.blockManager = this.world.GetBlockManager();
}
public TagSelectorView(ITagsManager tagsManager, IIdeaManager ideaManager,
IBlockManager blockManager, IRelationManager relationManager, ISettingsService settingsService, IMaterialManager materialManager)
{
_settingsService = settingsService;
var allDb = new AllDb
{
RelationManager = relationManager,
BlockManager = blockManager,
IdeaManager = ideaManager,
TagsManager = tagsManager,
MaterialManager = materialManager
};
InitializeComponent();
Loaded += (sender, args) =>
{
var model = RegionContext.GetObservableContext(this).Value as ISelectTagRegionView;
if (model != null)
{
var selectItem = new DelegateCommand<Guid>(id =>
{
if (model.TargetType == typeof(Tag))
_settingsService.AddRecentTag(id);
if (model.TargetType == typeof(Idea))
_settingsService.AddRecentIdea(id);
if (model.TargetType == typeof(Block))
_settingsService.AddRecentBlock(id);
if (model.TargetType == typeof(Comment))
_settingsService.AddRecentComment(id);
if (model.TargetType == typeof(Guidable))
_settingsService.AddRecentGuidable(id);
model.OkCommand.Execute(id);
});
var items = model.TargetType == typeof (Tag)
? _settingsService.GetRecentTags()
: model.TargetType == typeof (Idea)
? _settingsService.GetRecentIdeas()
: model.TargetType == typeof (Block)
? _settingsService.GetRecentBlocks()
: model.TargetType == typeof (Guidable)
? _settingsService.GetRecentGuidables()
: _settingsService.GetRecentComments();
var recent = new BarSubItem() {CategoryName = "BuiltInMenus", Content = "Recent"};
MainMenu.Items.Add(recent);
foreach (var item in items.OrderByDescending(i => i.Order))
recent.Items.Add(new BarButtonItem{Content = item.Name,
CommandParameter = item.Id, Command = selectItem});
}
DataContext = model;
};
_tagHelper = new TagTreeHelper(treeList, allDb);
_tagHelper.ReloadTree();
}
public async Task GlobalSetup()
{
_chains = GetRequiredService <IBlockchainStore <Chain> >();
_blockStateSets = GetRequiredService <INotModifiedCachedStateStore <BlockStateSet> >();
_chainManager = GetRequiredService <IChainManager>();
_blockManager = GetRequiredService <IBlockManager>();
_blockchainService = GetRequiredService <IBlockchainService>();
_blockAttachService = GetRequiredService <IBlockAttachService>();
_transactionManager = GetRequiredService <ITransactionManager>();
_osTestHelper = GetRequiredService <OSTestHelper>();
_chain = await _blockchainService.GetChainAsync();
}
public async Task GlobalSetup()
{
_chains = GetRequiredService <IBlockchainStore <Chain> >();
_chainBlockLinks = GetRequiredService <IBlockchainStore <ChainBlockLink> >();
_chainManager = GetRequiredService <IChainManager>();
_blockManager = GetRequiredService <IBlockManager>();
_transactionManager = GetRequiredService <ITransactionManager>();
_transactionPoolService = GetRequiredService <ITransactionPoolService>();
_blockchainService = GetRequiredService <IBlockchainService>();
_osTestHelper = GetRequiredService <OSTestHelper>();
_chain = await _blockchainService.GetChainAsync();
}
public CreateCommentDlgViewModel(IParticlesManager particlesManager, IBlockManager blockManager,
ICommentManager commentManager, IEventAggregator eventAggregator)
{
_particlesManager = particlesManager;
_blockManager = blockManager;
_commentManager = commentManager;
_eventAggregator = eventAggregator;
AddParticleVm = new AddParticleViewViewModel(particlesManager);
SelectBlockCommand = new DelegateCommand(() =>
{
var dlg = new SelectTagDlg(typeof (Guidable));
var res = dlg.ShowDialog();
if (res.HasValue && res.Value && dlg.Id.HasValue)
{
_myGuidable = _blockManager.GetGuidableById(dlg.Id.Value);
OkCommand.RaiseCanExecuteChanged();
if (_myGuidable is Material)
GuidableCaption = (_myGuidable as Material).Name;
else if (_myGuidable is Block)
GuidableCaption = (_myGuidable as Block).Caption;
}
});
OkCommand = new DelegateCommand<Window>((wnd) =>
{
var comment = _commentManager.CreateComment(Caption, _myGuidable);
if (AddParticleVm.AddParticle)
if (AddParticleVm.UseNewParticle)
{
var particle = _particlesManager.CreateParticle(AddParticleVm.NewParticle.Material,
AddParticleVm.NewParticle.Begin, AddParticleVm.NewParticle.End);
_blockManager.AddParticleToBlock(comment, particle);
ParticleId = particle.Id;
}
else if (AddParticleVm.UseExistParticle && AddParticleVm.ExistParticle.HasValue)
{
var particle = _particlesManager.GetParticleById(AddParticleVm.ExistParticle.Value);
_blockManager.AddParticleToBlock(comment, particle);
ParticleId = particle.Id;
}
_eventAggregator.GetEvent<BlockAddedEvent>().Publish(comment.Id);
wnd.DialogResult = true;
wnd.Close();
}, wnd => !String.IsNullOrWhiteSpace(Caption) && _myGuidable != null);
}
private const int BatchSize = 1000; // TODO: calculate batch size
public BlockProducer(
ITransactionPool transactionPool,
IValidatorManager validatorManager,
IBlockSynchronizer blockSynchronizer,
IBlockManager blockManager,
IStateManager stateManager,
ITransactionBuilder transactionBuilder
)
{
_transactionPool = transactionPool;
_validatorManager = validatorManager;
_blockSynchronizer = blockSynchronizer;
_blockManager = blockManager;
_stateManager = stateManager;
_transactionBuilder = transactionBuilder;
}
public ConspEditorMainViewModel(IIdeaManager ideaManager, IMaterialManager materialManager,
ITagsManager tagsManager, IParticlesManager particlesManager, IBlockManager blockManager,
IEventAggregator eventAggregator, IRelationManager relationManager, ICommentManager commentManager)
{
_ideaManager = ideaManager;
_materialManager = materialManager;
_tagsManager = tagsManager;
_particlesManager = particlesManager;
_blockManager = blockManager;
_eventAggregator = eventAggregator;
_relationManager = relationManager;
_commentManager = commentManager;
Bookmarks = new List<string>();
_eventAggregator.GetEvent<MaterialUpdatedEvent>().Subscribe(MaterialUpdated);
}
public BlockchainService(
ITransactionManager transactionManager,
IBlockManager blockManager,
ITransactionPool transactionPool,
IStateManager stateManager,
IBlockSynchronizer blockSynchronizer,
ISystemContractReader systemContractReader
)
{
_transactionPool = transactionPool;
_transactionManager = transactionManager;
_blockManager = blockManager;
_stateManager = stateManager;
_blockSynchronizer = blockSynchronizer;
_systemContractReader = systemContractReader;
}
public TextModel(IEventAggregator eventAggregator, IMaterialManager materialManager, Guid materialId,
IBlockManager blockManager, IParticlesManager particlesManager, TextEditor textEditor,
IUnityContainer container, ISettingsService settingsService)
{
_eventAggregator = eventAggregator;
_materialManager = materialManager;
_materialId = materialId;
_blockManager = blockManager;
_particlesManager = particlesManager;
_textEditor = textEditor;
_container = container;
_settingsService = settingsService;
Contstruct();
LoadToEditor();
}
public ConspEditorFastMainView(IMaterialManager materialManager,
IParticlesManager particlesManager, IEventAggregator eventAggregator, ConspEditorFastMainViewModel model, IBlockManager blockManager, IUnityContainer container, ISettingsService settingsService)
{
_materialManager = materialManager;
_particlesManager = particlesManager;
_eventAggregator = eventAggregator;
_blockManager = blockManager;
_container = container;
_settingsService = settingsService;
InitializeComponent();
DataContext = model;
textEditor.VerticalScrollBarVisibility = ScrollBarVisibility.Visible;
textEditor.Options.InheritWordWrapIndentation = false;
_eventAggregator.GetEvent<MaterialUpdatedEvent>().Subscribe(MaterialUpdated);
CreateMenu();
}
public void Setup()
{
_container?.Dispose();
TestUtils.DeleteTestChainData();
var containerBuilder = new SimpleInjectorContainerBuilder(new ConfigManager(
Path.Join(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "config2.json"),
new RunOptions()
));
containerBuilder.RegisterModule <BlockchainModule>();
containerBuilder.RegisterModule <ConfigModule>();
containerBuilder.RegisterModule <StorageModule>();
_container = containerBuilder.Build();
_configManager = _container.Resolve <IConfigManager>();
_stateManager = _container.Resolve <IStateManager>();
_contractRegisterer = _container.Resolve <IContractRegisterer>();
_privateWallet = _container.Resolve <IPrivateWallet>();
_snapshotIndexer = _container.Resolve <ISnapshotIndexRepository>();
_systemContractReader = _container.Resolve <ISystemContractReader>();
_transactionManager = _container.Resolve <ITransactionManager>();
_transactionBuilder = _container.Resolve <ITransactionBuilder>();
_transactionSigner = _container.Resolve <ITransactionSigner>();
_transactionPool = _container.Resolve <ITransactionPool>();
_blockManager = _container.Resolve <IBlockManager>();
// set chainId from config
if (TransactionUtils.ChainId(false) == 0)
{
var chainId = _configManager.GetConfig <NetworkConfig>("network")?.ChainId;
var newChainId = _configManager.GetConfig <NetworkConfig>("network")?.ChainId;
TransactionUtils.SetChainId((int)chainId !, (int)newChainId !);
HardforkHeights.SetHardforkHeights(_configManager.GetConfig <HardforkConfig>("hardfork") ?? throw new InvalidOperationException());
}
ServiceBinder.BindService <GenericParameterAttributes>();
_apiService = new AccountServiceWeb3(_stateManager, _snapshotIndexer, _contractRegisterer, _systemContractReader, _transactionPool);
_transactionApiService = new TransactionServiceWeb3(_stateManager, _transactionManager, _transactionBuilder, _transactionSigner,
_transactionPool, _contractRegisterer, _privateWallet);
_blockManager.TryBuildGenesisBlock();
}
public CreateIdeaDlgViewModel(ITagsManager tagsManager, IParticlesManager particleManager,
IIdeaManager ideaManager, IBlockManager blockManager, IEventAggregator eventAggregator)
{
_tagsManager = tagsManager;
_particleManager = particleManager;
_ideaManager = ideaManager;
_blockManager = blockManager;
_eventAggregator = eventAggregator;
AddParticleVm = new AddParticleViewViewModel(_particleManager);
OkCommand = new DelegateCommand<Window>((wnd) =>
{
var idea = _ideaManager.CreateIdea(Caption);
if (_parentTag != null)
_ideaManager.AddTagToIdea(idea, _parentTag);
if (AddParticleVm.AddParticle)
if (AddParticleVm.UseNewParticle)
{
var particle = _particleManager.CreateParticle(AddParticleVm.NewParticle.Material,
AddParticleVm.NewParticle.Begin, AddParticleVm.NewParticle.End);
_blockManager.AddParticleToBlock(idea, particle);
}
else if (AddParticleVm.UseExistParticle && AddParticleVm.ExistParticle.HasValue)
{
var particle = _particleManager.GetParticleById(AddParticleVm.ExistParticle.Value);
_blockManager.AddParticleToBlock(idea, particle);
}
_eventAggregator.GetEvent<BlockAddedEvent>().Publish(idea.Id);
wnd.DialogResult = true;
wnd.Close();
}, wnd => !String.IsNullOrWhiteSpace(Caption));
SelectTagCommand = new DelegateCommand(() =>
{
var dlg = new SelectTagDlg(typeof (Tag));
var res = dlg.ShowDialog();
if (res.HasValue && res.Value && dlg.Id.HasValue)
{
_parentTag = _tagsManager.GetTagById(dlg.Id.Value);
TagCaption = _parentTag.Caption;
AddToTag = true;
}
});
}
public BlockSynchronizer(
ITransactionManager transactionManager,
IBlockManager blockManager,
INetworkBroadcaster networkBroadcaster,
INetworkManager networkManager,
ITransactionPool transactionPool,
IStateManager stateManager
)
{
_transactionManager = transactionManager;
_blockManager = blockManager;
_networkBroadcaster = networkBroadcaster;
_networkManager = networkManager;
_transactionPool = transactionPool;
_stateManager = stateManager;
_blockSyncThread = new Thread(BlockSyncWorker);
_pingThread = new Thread(PingWorker);
}
public DeduplicatingBlockStore(IBlockManager virtualBlockManager, IBlockStore virtualBlockStore, IBlockStore rawBlockStore, IBlockManager rawBlockManager, ulong virtualBlockCount, IUsageCountStore rawBlockUsageCountStore, IHashManager<uint> rawBlockHashManager)
{
if (virtualBlockManager == null)
{
throw new ArgumentNullException("virtualBlockManager");
}
if (virtualBlockStore == null)
{
throw new ArgumentNullException("virtualBlockStore");
}
if (rawBlockStore == null)
{
throw new ArgumentNullException("rawBlockStore");
}
if (rawBlockManager == null)
{
throw new ArgumentNullException("rawBlockManager");
}
if (rawBlockUsageCountStore == null)
{
throw new ArgumentNullException("rawBlockUsageCountStore");
}
if (rawBlockHashManager == null)
{
throw new ArgumentNullException("rawBlockHashManager");
}
_virtualBlockManager = virtualBlockManager;
_virtualBlockStore = virtualBlockStore;
_rawBlockStore = rawBlockStore;
_rawBlockManager = rawBlockManager;
_virtualBlockCount = virtualBlockCount;
_rawBlockUsageCountStore = rawBlockUsageCountStore;
_rawBlockHashManager = rawBlockHashManager;
_blockSize = rawBlockStore.BlockSize;
if (virtualBlockStore.BlockCount != _virtualBlockCount)
{
throw new Exception(String.Format("BlockCount of VirtualBlockStore not correct! (Expected = {0}, Actual = {1})", _virtualBlockCount, virtualBlockStore.BlockCount));
}
_rawBlockBufferPool = new ObjectPool<ArraySegment<byte>>(() => new ArraySegment<byte>(new byte[_blockSize]));
_virtualBlockBufferPool = new ObjectPool<ArraySegment<byte>>(() => new ArraySegment<byte>(new byte[8]));
}
public ConsoleManager(
ITransactionBuilder transactionBuilder,
ITransactionPool transactionPool,
ITransactionManager transactionManager,
ITransactionSigner transactionSigner,
IBlockManager blockManager,
IStateManager stateManager,
ISystemContractReader systemContractReader,
IValidatorStatusManager validatorStatusManager
)
{
_blockManager = blockManager;
_transactionBuilder = transactionBuilder;
_transactionPool = transactionPool;
_transactionManager = transactionManager;
_transactionSigner = transactionSigner;
_stateManager = stateManager;
_systemContractReader = systemContractReader;
_validatorStatusManager = validatorStatusManager;
}
public RpcManager(
ITransactionManager transactionManager,
IBlockManager blockManager,
IConfigManager configManager,
IStateManager stateManager,
ISnapshotIndexRepository snapshotIndexer,
ITransactionPool transactionPool,
IVirtualMachine virtualMachine,
IContractRegisterer contractRegisterer,
IValidatorStatusManager validatorStatusManager,
ISystemContractReader systemContractReader,
IBlockSynchronizer blockSynchronizer,
ILocalTransactionRepository localTransactionRepository,
ITransactionSigner transactionSigner,
IPrivateWallet privateWallet,
ITransactionBuilder transactionBuilder,
IBlockchainEventFilter blockchainEventFilter,
INetworkManager networkManager,
INodeRetrieval nodeRetrieval,
IConsensusManager consensusManager
)
{
_transactionManager = transactionManager;
_blockManager = blockManager;
_configManager = configManager;
_stateManager = stateManager;
_snapshotIndexer = snapshotIndexer;
_transactionPool = transactionPool;
_contractRegisterer = contractRegisterer;
_validatorStatusManager = validatorStatusManager;
_systemContractReader = systemContractReader;
_blockSynchronizer = blockSynchronizer;
_localTransactionRepository = localTransactionRepository;
_transactionSigner = transactionSigner;
_transactionBuilder = transactionBuilder;
_privateWallet = privateWallet;
_blockchainEventFilter = blockchainEventFilter;
_networkManager = networkManager;
_nodeRetrieval = nodeRetrieval;
_consensusManager = consensusManager;
}
public TransactionPool(
ITransactionVerifier transactionVerifier,
IPoolRepository poolRepository,
ITransactionManager transactionManager,
IBlockManager blockManager,
INonceCalculator nonceCalculator,
IStateManager stateManager,
ITransactionHashTrackerByNonce transactionHashTracker
)
{
_transactionVerifier = transactionVerifier;
_poolRepository = poolRepository;
_transactionManager = transactionManager;
_blockManager = blockManager;
_nonceCalculator = nonceCalculator;
_stateManager = stateManager;
_transactionHashTracker = transactionHashTracker;
_transactionsQueue = new HashSet <TransactionReceipt>();
_blockManager.OnBlockPersisted += OnBlockPersisted;
}
public BlockchainServiceWeb3(
ITransactionManager transactionManager,
IBlockManager blockManager,
ITransactionPool transactionPool,
IStateManager stateManager,
ISnapshotIndexRepository snapshotIndexer,
INetworkManager networkManager,
INodeRetrieval nodeRetrieval,
ISystemContractReader systemContractReader,
IConsensusManager consensusManager)
{
_transactionPool = transactionPool;
_transactionManager = transactionManager;
_blockManager = blockManager;
_stateManager = stateManager;
_snapshotIndexer = snapshotIndexer;
_networkManager = networkManager;
_nodeRetrieval = nodeRetrieval;
_systemContractReader = systemContractReader;
_consensusManager = consensusManager;
}
public RemotePanel()
{
InitializeComponent();
BlockManager = new BlockManager();
foreach (IBlock block in BlockManager.BlockTypes)
{
listAdd.Items.Add(block.BlockItem);
}
BlockList = new BlockList();
BlockList.MouseDoubleClick += OnMouseDoubleClick;
ccBlockList.Content = BlockList;
BlockList.OrderChanged += ListBlocks_OrderChanged;
BlockList.SelectionChanged += ListBlocks_SelectionChanged;
listCode.SelectionChanged += ListCode_SelectionChanged;
AddTimer = new DispatcherTimer();
AddTimer.Tick += AddTimer_Tick;
AddTimer.Interval = TimeSpan.FromMilliseconds(200);
}
private DeduplicatingBlockStore CreateStore(uint blockSize, ulong virtualBlockCount, ulong rawBlockCount)
{
var xBaseDir = Path.Combine(Environment.CurrentDirectory, StoreSubdir);
if (Directory.Exists(xBaseDir))
{
Directory.Delete(xBaseDir, true);
}
Directory.CreateDirectory(xBaseDir);
var xRawStoreSize = rawBlockCount * blockSize;
var xRawBlockStoreFS = new FileStream(Path.Combine(xBaseDir, "RawBlocks.bin"), FileMode.CreateNew);
xRawBlockStoreFS.SetLength((long)xRawStoreSize);
var xRawBlockStore = new SimpleStreamBlockStore(xRawBlockStoreFS, blockSize);
var xRawBlockManagerFS = new FileStream(Path.Combine(xBaseDir, "RawBlockBitmap.bin"), FileMode.CreateNew);
xRawBlockManagerFS.SetLength((long)(xRawBlockStore.BlockCount / 8));
mRawBlockManager = new BitmapBlockManager(xRawBlockManagerFS, (ulong)(xRawBlockManagerFS.Length / blockSize), blockSize);
var xVirtualBlockManagerFS = new FileStream(Path.Combine(xBaseDir, "VirtualBlocksBitmap.bin"), FileMode.CreateNew);
xVirtualBlockManagerFS.SetLength((long)(virtualBlockCount /8 ));
var xVirtualBlockManager = new BitmapBlockManager(xVirtualBlockManagerFS, virtualBlockCount / blockSize / 8, blockSize);
var xVirtualBlockStoreFS = new FileStream(Path.Combine(xBaseDir, "VirtualBlocks.bin"), FileMode.CreateNew);
xVirtualBlockStoreFS.SetLength((long)(virtualBlockCount * 8));
var xVirtualBlockStore = new SimpleStreamBlockStore(xVirtualBlockStoreFS, 8);
var xRawBlockUsageCounterFS = new FileStream(Path.Combine(xBaseDir, "RawBlockUsageCounts.bin"), FileMode.CreateNew);
xRawBlockUsageCounterFS.SetLength((long)(rawBlockCount * 8));
var xRawBlockUsageCounterStore = new SimpleStreamBlockStore(xRawBlockUsageCounterFS, blockSize);
var xRawBlockUsageCounter = new SimpleUsageCountStore(xRawBlockUsageCounterStore);
var xHashesDir = Path.Combine(xBaseDir, "Hashes");
SimpleHashManager.Create(xHashesDir);
var xHashManager = new SimpleHashManager(xHashesDir);
return new DeduplicatingBlockStore(xVirtualBlockManager, xVirtualBlockStore, xRawBlockStore, mRawBlockManager, virtualBlockCount,
xRawBlockUsageCounter, xHashManager);
}
public ConsoleCommands(
ITransactionBuilder transactionBuilder,
ITransactionPool transactionPool,
ITransactionManager transactionManager,
ITransactionSigner transactionSigner,
IBlockManager blockManager,
IStateManager stateManager,
ISystemContractReader systemContractReader,
IValidatorStatusManager validatorStatusManager,
EcdsaKeyPair keyPair
)
{
_blockManager = blockManager;
_transactionBuilder = transactionBuilder;
_transactionPool = transactionPool;
_transactionManager = transactionManager;
_transactionSigner = transactionSigner;
_stateManager = stateManager;
_systemContractReader = systemContractReader;
_validatorStatusManager = validatorStatusManager;
_keyPair = keyPair;
}
public MessageHandler(
IBlockSynchronizer blockSynchronizer,
ITransactionPool transactionPool,
IStateManager stateManager,
IConsensusManager consensusManager,
IBlockManager blockManager,
INetworkManager networkManager
)
{
_blockSynchronizer = blockSynchronizer;
_transactionPool = transactionPool;
_stateManager = stateManager;
_consensusManager = consensusManager;
_networkManager = networkManager;
blockManager.OnBlockPersisted += BlockManagerOnBlockPersisted;
transactionPool.TransactionAdded += TransactionPoolOnTransactionAdded;
_networkManager.OnPingReply += OnPingReply;
_networkManager.OnSyncBlocksRequest += OnSyncBlocksRequest;
_networkManager.OnSyncBlocksReply += OnSyncBlocksReply;
_networkManager.OnSyncPoolRequest += OnSyncPoolRequest;
_networkManager.OnSyncPoolReply += OnSyncPoolReply;
_networkManager.OnConsensusMessage += OnConsensusMessage;
}
public KeyGenManager(
IBlockManager blockManager,
ITransactionManager transactionManager,
ITransactionBuilder transactionBuilder,
IPrivateWallet privateWallet,
ITransactionPool transactionPool,
ITransactionSigner transactionSigner,
IKeyGenRepository keyGenRepository,
IBlockSynchronizer blockSynchronizer,
ISystemContractReader systemContractReader
)
{
_blockManager = blockManager;
_transactionManager = transactionManager;
_transactionBuilder = transactionBuilder;
_privateWallet = privateWallet;
_transactionPool = transactionPool;
_transactionSigner = transactionSigner;
_keyGenRepository = keyGenRepository;
_blockSynchronizer = blockSynchronizer;
_systemContractReader = systemContractReader;
_blockManager.OnSystemContractInvoked += BlockManagerOnSystemContractInvoked;
}
public void Construct(IBlockManager blockManager)
{
this.blockManager = blockManager;
}
public BlockController(ISettingsManager settingsManager, IBlockManager blockManager, IRuleRepository ruleRepository)
{
_settingsManager = settingsManager;
_blockManager = blockManager;
_ruleRepository = ruleRepository;
}
public CreateIdeaDlgViewModel(ITagsManager tagsManager, IParticlesManager particleManager,
IIdeaManager ideaManager, IBlockManager blockManager, IEventAggregator eventAggregator, ISettingsService settingsService)
{
_tagsManager = tagsManager;
_particleManager = particleManager;
_ideaManager = ideaManager;
_blockManager = blockManager;
_eventAggregator = eventAggregator;
_settingsService = settingsService;
RecentTags = new List<RecentTag>();
RecentTags.AddRange(
settingsService.GetRecentTags()
.Select(a => new RecentTag() {Id = a.Id, TagLong = a.Name,
TagShort = a.Name.Substring(0, Math.Min(a.Name.Length, 20)) + (Math.Min(a.Name.Length, 20) == 20 ? "...;" : ";")
}));
AddParticleVm = new AddParticleViewViewModel(_particleManager);
OkCommand = new DelegateCommand<Window>((wnd) =>
{
var idea = _ideaManager.CreateIdea(Caption);
if (_parentTag != null)
_ideaManager.AddTagToIdea(idea, _parentTag);
if (AddParticleVm.AddParticle)
if (AddParticleVm.UseNewParticle)
{
var particle = _particleManager.CreateParticle(AddParticleVm.NewParticle.Material,
AddParticleVm.NewParticle.Begin, AddParticleVm.NewParticle.End);
_blockManager.AddParticleToBlock(idea, particle);
ParticleId = particle.Id;
}
else if (AddParticleVm.UseExistParticle && AddParticleVm.ExistParticle.HasValue)
{
var particle = _particleManager.GetParticleById(AddParticleVm.ExistParticle.Value);
_blockManager.AddParticleToBlock(idea, particle);
ParticleId = particle.Id;
}
IdeaId = idea.Id;
_eventAggregator.GetEvent<BlockAddedEvent>().Publish(idea.Id);
wnd.DialogResult = true;
wnd.Close();
}, wnd => !String.IsNullOrWhiteSpace(Caption));
SelectTagCommand = new DelegateCommand(() =>
{
var dlg = new SelectTagDlg(typeof (Tag));
var res = dlg.ShowDialog();
if (res.HasValue && res.Value && dlg.Id.HasValue)
{
_parentTag = _tagsManager.GetTagById(dlg.Id.Value);
TagCaption = _parentTag.Caption;
AddToTag = true;
}
});
ClickTagCommand = new DelegateCommand<RecentTag>(rt =>
{
_parentTag = _tagsManager.GetTagById(rt.Id);
TagCaption = _parentTag.Caption;
AddToTag = true;
});
}
public AddLayerAreaAddController(IAuthManager authManager, ISiteRepository siteRepository, IBlockManager blockManager)
{
_authManager = authManager;
_siteRepository = siteRepository;
_blockManager = blockManager;
}
public void Start(RunOptions options)
{
_blockManager = _container.Resolve <IBlockManager>();
_configManager = _container.Resolve <IConfigManager>();
_stateManager = _container.Resolve <IStateManager>();
_transactionBuilder = _container.Resolve <ITransactionBuilder>();
_transactionPool = _container.Resolve <ITransactionPool>();
_transactionSigner = _container.Resolve <ITransactionSigner>();
_wallet = _container.Resolve <IPrivateWallet>();
var keyPair = _wallet.EcdsaKeyPair;
Console.WriteLine("-------------------------------");
Console.WriteLine("Private Key: " + keyPair.PrivateKey.Encode().ToHex());
Console.WriteLine("Public Key: " + keyPair.PublicKey.EncodeCompressed().ToHex());
Console.WriteLine("Address: " + Crypto.ComputeAddress(keyPair.PublicKey.EncodeCompressed()).ToHex());
Console.WriteLine("-------------------------------");
if (_blockManager.TryBuildGenesisBlock())
{
Console.WriteLine("Generated genesis block");
}
var genesisBlock = _stateManager.LastApprovedSnapshot.Blocks.GetBlockByHeight(0);
Console.WriteLine("Genesis Block: " + genesisBlock !.Hash.ToHex());
Console.WriteLine($" + prevBlockHash: {genesisBlock.Header.PrevBlockHash.ToHex()}");
Console.WriteLine($" + merkleRoot: {genesisBlock.Header.MerkleRoot.ToHex()}");
Console.WriteLine($" + nonce: {genesisBlock.Header.Nonce}");
Console.WriteLine($" + transactionHashes: {genesisBlock.TransactionHashes.Count}");
foreach (var s in genesisBlock.TransactionHashes)
{
Console.WriteLine($" + - {s.ToHex()}");
}
Console.WriteLine($" + hash: {genesisBlock.Hash.ToHex()}");
var address1 = "0xe3c7a20ee19c0107b9121087bcba18eb4dcb8576".HexToUInt160();
var address2 = "0x6bc32575acb8754886dc283c2c8ac54b1bd93195".HexToUInt160();
Console.WriteLine("-------------------------------");
// Console.WriteLine("Current block header height: " + blockchainContext.CurrentBlockHeight);
Console.WriteLine("-------------------------------");
Console.WriteLine("Balance of LA 0x3e: " +
_stateManager.LastApprovedSnapshot.Balances.GetBalance(address1));
Console.WriteLine("Balance of LA 0x6b: " +
_stateManager.LastApprovedSnapshot.Balances.GetBalance(address2));
Console.WriteLine("-------------------------------");
Logger.LogInformation($"Setting chainId");
var chainId = _configManager.GetConfig <NetworkConfig>("network")?.ChainId ?? 42;
var newChainId = _configManager.GetConfig <NetworkConfig>("network")?.NewChainId ?? chainId;
TransactionUtils.SetChainId((int)chainId, newChainId);
// _BenchTxProcessing(_transactionBuilder, _transactionSigner, keyPair);
// _BenchOneTxInBlock(_transactionBuilder, _transactionSigner, keyPair);
Console.WriteLine("---------------START - TX POOL BENCHMARK----------------");
_Bench_Tx_Pool(_transactionBuilder, _transactionSigner, keyPair);
Console.WriteLine("---------------END - TX POOL BENCHMARK----------------");
Console.WriteLine("---------------START - BLOCK EMULATE BENCHMARK----------------");
_Bench_Emulate_Block(_transactionBuilder, _transactionSigner, keyPair);
Console.WriteLine("---------------END - BLOCK EMULATE BENCHMARK----------------");
Console.WriteLine("---------------START - BLOCK EMULATE + EXECUTE BENCHMARK----------------");
_Bench_Emulate_Execute_Tx(_transactionBuilder, _transactionSigner, keyPair);
Console.WriteLine("---------------END - BLOCK EMULATE + EXECUTE BENCHMARK----------------");
Console.WriteLine("---------------START - MULTIPLE BLOCKS EMULATE + EXECUTE BENCHMARK----------------");
_Bench_Execute_Blocks(_transactionBuilder, _transactionSigner, keyPair);
Console.WriteLine("---------------END - MULTIPLE BLOCKS EMULATE + EXECUTE BENCHMARK----------------");
Environment.Exit(0);
}
public async Task GlobalSetup()
{
_chains = GetRequiredService <IBlockchainStore <Chain> >();
_chainStateInfoCollection = GetRequiredService <IStateStore <ChainStateInfo> >();
_blockchainStateManager = GetRequiredService <IBlockchainStateManager>();
_blockchainStateService = GetRequiredService <IBlockchainStateService>();
_blockStateSetManger = GetRequiredService <IBlockStateSetManger>();
_blockchainService = GetRequiredService <IBlockchainService>();
_osTestHelper = GetRequiredService <OSTestHelper>();
_chainManager = GetRequiredService <IChainManager>();
_blockManager = GetRequiredService <IBlockManager>();
_transactionManager = GetRequiredService <ITransactionManager>();
_transactionResultManager = GetRequiredService <ITransactionResultManager>();
_txHub = GetRequiredService <ITxHub>();
_blockStateSets = new List <BlockStateSet>();
_blocks = new List <Block>();
_chain = await _blockchainService.GetChainAsync();
var blockHash = _chain.BestChainHash;
while (true)
{
var blockState = await _blockStateSetManger.GetBlockStateSetAsync(blockHash);
_blockStateSets.Add(blockState);
var blockHeader = await _blockchainService.GetBlockHeaderByHashAsync(blockHash);
blockHash = blockHeader.PreviousBlockHash;
if (blockHash == _chain.LastIrreversibleBlockHash)
{
break;
}
}
await _blockchainStateService.MergeBlockStateAsync(_chain.BestChainHeight, _chain.BestChainHash);
for (var i = 0; i < BlockCount; i++)
{
var transactions = await _osTestHelper.GenerateTransferTransactions(TransactionCount);
await _osTestHelper.BroadcastTransactions(transactions);
var block = await _osTestHelper.MinedOneBlock();
_blocks.Add(block);
var blockState = await _blockStateSetManger.GetBlockStateSetAsync(block.GetHash());
_blockStateSets.Add(blockState);
}
var chain = await _blockchainService.GetChainAsync();
await _chainManager.SetIrreversibleBlockAsync(chain, chain.BestChainHash);
_chainStateInfo = await _chainStateInfoCollection.GetAsync(chain.Id.ToStorageKey());
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (Space != null)
{
Space.Dispose();
Space = null;
}
// ReSharper disable SuspiciousTypeConversion.Global
var disposable = BlockManager as IDisposable;
// ReSharper restore SuspiciousTypeConversion.Global
if (disposable != null)
{
disposable.Dispose();
}
BlockManager = null;
}
}
public AddController(IAuthManager authManager, IChannelRepository channelRepository, IRuleRepository ruleRepository, IBlockManager blockManager)
{
_authManager = authManager;
_channelRepository = channelRepository;
_ruleRepository = ruleRepository;
_blockManager = blockManager;
}
public bool Generate (IBlockManager blockMan, Random rand, int x, int y, int z)
{
float rpi = (float)(rand.NextDouble() * Math.PI);
double x1 = x + 8 + MathHelper.Sin(rpi) * _size / 8.0F;
double x2 = x + 8 - MathHelper.Sin(rpi) * _size / 8.0F;
double z1 = z + 8 + MathHelper.Cos(rpi) * _size / 8.0F;
double z2 = z + 8 - MathHelper.Cos(rpi) * _size / 8.0F;
double y1 = y + rand.Next(3) + 2;
double y2 = y + rand.Next(3) + 2;
for (int i = 0; i <= _size; i++) {
double xPos = x1 + (x2 - x1) * i / _size;
double yPos = y1 + (y2 - y1) * i / _size;
double zPos = z1 + (z2 - z1) * i / _size;
double fuzz = rand.NextDouble() * _size / 16.0D;
double fuzzXZ = (MathHelper.Sin((float)(i * Math.PI / _size)) + 1.0F) * fuzz + 1.0D;
double fuzzY = (MathHelper.Sin((float)(i * Math.PI / _size)) + 1.0F) * fuzz + 1.0D;
int xStart, yStart, zStart, xEnd, yEnd, zEnd;
if (_mathFix) {
xStart = (int)Math.Floor(xPos - fuzzXZ / 2.0D);
yStart = (int)Math.Floor(yPos - fuzzY / 2.0D);
zStart = (int)Math.Floor(zPos - fuzzXZ / 2.0D);
xEnd = (int)Math.Floor(xPos + fuzzXZ / 2.0D);
yEnd = (int)Math.Floor(yPos + fuzzY / 2.0D);
zEnd = (int)Math.Floor(zPos + fuzzXZ / 2.0D);
}
else {
xStart = (int)(xPos - fuzzXZ / 2.0D);
yStart = (int)(yPos - fuzzY / 2.0D);
zStart = (int)(zPos - fuzzXZ / 2.0D);
xEnd = (int)(xPos + fuzzXZ / 2.0D);
yEnd = (int)(yPos + fuzzY / 2.0D);
zEnd = (int)(zPos + fuzzXZ / 2.0D);
}
for (int ix = xStart; ix <= xEnd; ix++) {
double xThresh = (ix + 0.5D - xPos) / (fuzzXZ / 2.0D);
if (xThresh * xThresh < 1.0D) {
for (int iy = yStart; iy <= yEnd; iy++) {
double yThresh = (iy + 0.5D - yPos) / (fuzzY / 2.0D);
if (xThresh * xThresh + yThresh * yThresh < 1.0D) {
for (int iz = zStart; iz <= zEnd; iz++) {
double zThresh = (iz + 0.5D - zPos) / (fuzzXZ / 2.0D);
if (xThresh * xThresh + yThresh * yThresh + zThresh * zThresh < 1.0D) {
AlphaBlockRef block = blockMan.GetBlockRef(ix, iy, iz);
if (block.IsValid) {
block.ID = _blockId;
block.Data = _blockData;
}
}
}
}
}
}
}
}
return true;
}
public WorldStamp(NbtWorld world)
{
_world = world;
_blockManager = _world.GetBlockManager();
}
public BlockManagerTests()
{
_blockManager = GetRequiredService <IBlockManager>();
_kernelTestHelper = GetRequiredService <KernelTestHelper>();
}
public TagsManagerMainViewModel(ITagsManager tagsManager, IBlockManager blockManager,
EventAggregator eventAggregator, IReferenceManager referenceManager, IRelationManager relationManager,
IIdeaManager ideaManager, ISharedService shared, IMaterialManager materialManager, IParticlesManager particlesManager)
{
_eventAggregator = eventAggregator;
_shared = shared;
_db = new AllDb()
{
TagsManager = tagsManager,
RelationManager = relationManager,
IdeaManager = ideaManager,
BlockManager = blockManager,
MaterialManager = materialManager,
ParticlesManager = particlesManager
};
_eventAggregator.GetEvent<BlockAddedEvent>().Subscribe(guid =>
{
var block = _db.BlockManager.GetBlockById(guid);
if (block is Idea)
{
var ideaDto = IdeaDto.FromBase(block as Idea, _db);
OnNodeAdded(ideaDto);
}
if (block is Relation)
{
var relDto = RelationDto.FromBase(block as Relation, _db);
OnNodeAdded(relDto);
}
if (block is Comment)
{
var commDto = CommentDto.FromBase(block as Comment, _db);
OnNodeAdded(commDto);
}
});
_eventAggregator.GetEvent<DatabaseImportedEvent>().Subscribe(s => OnRefresh());
_eventAggregator.GetEvent<MaterialUpdatedEvent>().Subscribe(guid =>
{
var mat = _db.MaterialManager.GetMaterialById(guid);
var matDto = MaterialDto.FromBase(mat, _db);
OnMaterialUpdate(matDto as MaterialDto);
});
NewTagCommand = new DelegateCommand<TreeItemDto>((dto) =>
{
if (dto == null || dto is TagDto)
{
var added = _db.TagsManager.AddTag(dto == null ? null : (Guid?) dto.Id, "New tag");
var addedDto = TagDto.FromBase(added, _db);
OnNodeAdded(addedDto);
OnRenameTag(addedDto);
}
});
NewIdeaCommand = new DelegateCommand<TreeItemDto>(dto =>
{
/*var added = _ideaManager.CreateIdea("New idea");
var addedDto = _map.Map<IdeaDto>(added);
OnNodeAdded(addedDto);
OnRenameTag(addedDto);*/
});
AddReferenceCommand = new DelegateCommand<TreeItemDto>(dto =>
{
if (dto is IdeaDto || dto is RelationDto)
{
var dlgVm = new CreateReferenceDlgViewModel(_db.BlockManager, dto);
if (shared.SelectedParticle != Guid.Empty)
{
var pis = _db.ParticlesManager.GetParticleInplacesForParticle(shared.SelectedParticle);
if (pis != null && pis.Any())
{
var block = _db.BlockManager.GetBlockById(pis.First().BlockId) as Idea;
if (block != null)
dlgVm.Block2 = new NamedGuid() {Caption = block.Caption, Uid = block.Id};
}
}
var dlg = new CreateReferenceDlg(dlgVm);
var res = dlg.ShowDialog();
if (res.HasValue && res.Value)
{
if (dlgVm.IsTo || dlgVm.IsBoth)
{
var refer = referenceManager.CreateReference(dlgVm.Block1.Uid, dlgVm.Block2.Uid);
OnNodeAdded(ReferenceDto.FromBase(refer, _db));
}
if (dlgVm.IsFrom || dlgVm.IsBoth)
{
var refer = referenceManager.CreateReference(dlgVm.Block2.Uid, dlgVm.Block1.Uid);
OnNodeAdded(ReferenceDto.FromBase(refer, _db));
}
}
}
});
ClearCommand = new DelegateCommand(() =>
{
tagsManager.DeleteAllTAgs();
OnRefresh();
});
OpenIdeaCommand = new DelegateCommand<TreeItemDto>(dto =>
{
if (dto is IdeaDto)
Interfaces.CompositeCommands.OpenBlockCommand.Execute(dto.Id);
if (dto is MaterialDto)
Interfaces.CompositeCommands.OpenSourceCommand.Execute(dto.Id);
});
RenameCommand = new DelegateCommand<TreeItemDto>(OnRenameTag);
AddCurrentMaterialCommand = new DelegateCommand<TagDto>(dto =>
{
if (_shared.CurrentMaterial.HasValue)
{
_db.TagsManager.ApplyTagToMaterial(_shared.CurrentMaterial.Value, dto.Id);
var m = _db.MaterialManager.GetMaterialById(_shared.CurrentMaterial.Value);
var addedDto = MaterialDto.FromBase(m, _db);
OnNodeAdded(addedDto);
}
});
DeleteCommand = new DelegateCommand<TreeItemDto>(dto =>
{
if (dto is IdeaDto)
{
_db.IdeaManager.DeleteIdea((dto as IdeaDto).Id);
NodeAnnihilated(dto);
}
});
}
/// <summary>
/// Initializes a new instance of the <see cref="ConfigCreateFromManager"/> class.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="moduleServiceManager">The module service manager.</param>
/// <param name="defaultValueManager">The default value manager.</param>
/// <param name="blockManager">The block manager.</param>
public ConfigCreateFromManager(ILogger <ConfigCreateFromManager> logger, IModuleServiceManager moduleServiceManager, IDefaultValueManager defaultValueManager, IBlockManager blockManager) : base(logger)
{
EnsureArg.IsNotNull(logger, nameof(logger));
EnsureArg.IsNotNull(defaultValueManager, nameof(defaultValueManager));
EnsureArg.IsNotNull(blockManager, nameof(blockManager));
EnsureArg.IsNotNull(moduleServiceManager, nameof(moduleServiceManager));
_blockManager = blockManager;
_defaultValueManager = defaultValueManager;
_logger = logger;
_moduleServiceManager = moduleServiceManager;
}
public QueryController(IAuthManager authManager, IBlockManager blockManager, IRuleRepository ruleRepository)
{
_authManager = authManager;
_blockManager = blockManager;
_ruleRepository = ruleRepository;
}
public Chunk() {
_blockManager = Constants.Kernel.Get<IBlockManager>();
}
public bool Generate(IBlockManager blockMan, Random rand, int x, int y, int z)
{
float rpi = (float)(rand.NextDouble() * Math.PI);
double x1 = x + 8 + MathHelper.Sin(rpi) * _size / 8.0F;
double x2 = x + 8 - MathHelper.Sin(rpi) * _size / 8.0F;
double z1 = z + 8 + MathHelper.Cos(rpi) * _size / 8.0F;
double z2 = z + 8 - MathHelper.Cos(rpi) * _size / 8.0F;
double y1 = y + rand.Next(3) + 2;
double y2 = y + rand.Next(3) + 2;
for (int i = 0; i <= _size; i++)
{
double xPos = x1 + (x2 - x1) * i / _size;
double yPos = y1 + (y2 - y1) * i / _size;
double zPos = z1 + (z2 - z1) * i / _size;
double fuzz = rand.NextDouble() * _size / 16.0D;
double fuzzXZ = (MathHelper.Sin((float)(i * Math.PI / _size)) + 1.0F) * fuzz + 1.0D;
double fuzzY = (MathHelper.Sin((float)(i * Math.PI / _size)) + 1.0F) * fuzz + 1.0D;
int xStart, yStart, zStart, xEnd, yEnd, zEnd;
if (_mathFix)
{
xStart = (int)Math.Floor(xPos - fuzzXZ / 2.0D);
yStart = (int)Math.Floor(yPos - fuzzY / 2.0D);
zStart = (int)Math.Floor(zPos - fuzzXZ / 2.0D);
xEnd = (int)Math.Floor(xPos + fuzzXZ / 2.0D);
yEnd = (int)Math.Floor(yPos + fuzzY / 2.0D);
zEnd = (int)Math.Floor(zPos + fuzzXZ / 2.0D);
}
else
{
xStart = (int)(xPos - fuzzXZ / 2.0D);
yStart = (int)(yPos - fuzzY / 2.0D);
zStart = (int)(zPos - fuzzXZ / 2.0D);
xEnd = (int)(xPos + fuzzXZ / 2.0D);
yEnd = (int)(yPos + fuzzY / 2.0D);
zEnd = (int)(zPos + fuzzXZ / 2.0D);
}
for (int ix = xStart; ix <= xEnd; ix++)
{
double xThresh = (ix + 0.5D - xPos) / (fuzzXZ / 2.0D);
if (xThresh * xThresh < 1.0D)
{
for (int iy = yStart; iy <= yEnd; iy++)
{
double yThresh = (iy + 0.5D - yPos) / (fuzzY / 2.0D);
if (xThresh * xThresh + yThresh * yThresh < 1.0D)
{
for (int iz = zStart; iz <= zEnd; iz++)
{
double zThresh = (iz + 0.5D - zPos) / (fuzzXZ / 2.0D);
if (xThresh * xThresh + yThresh * yThresh + zThresh * zThresh < 1.0D)
{
AlphaBlockRef block = blockMan.GetBlockRef(ix, iy, iz);
if (block.IsValid)
{
block.ID = _blockId;
block.Data = _blockData;
}
}
}
}
}
}
}
}
return(true);
}
public BlockManagerTests()
{
_blockManager = GetRequiredService <IBlockManager>();
}
public HospitalStructureContext(IBlockManager blockManager, IWardManager wardManager, IRoomManager roomManager)
{
_blockManager = blockManager;
_wardManager = wardManager;
_roomManager = roomManager;
}
public BlockViewerViewModel(IBlockManager blockManager)
{
_blockManager = blockManager;
}
internal VirtualDiskImpl([NotNull] IBlockManager blockManager, [NotNull] ILockingPolicy lockingPolicy)
{
_blockManager = blockManager;
_lockingPolicy = lockingPolicy;
_rootDirectory = new VirtualRootDirectoryImpl(this);
}
public BlockExecutingServiceTests()
{
_blockExecutingService = GetRequiredService <BlockExecutingService>();
_blockManager = GetRequiredService <IBlockManager>();
_blockchainStateManager = GetRequiredService <IBlockchainStateManager>();
}
public TransactionBlocksController()
{
this.smartContractDb = new SmartContractDb();
this.blockManager = new BlockManager(this.smartContractDb);
}
public CreateRelationDlgViewModel(IParticlesManager particlesManager, IIdeaManager ideaManager,
IRelationManager relationManager, IBlockManager blockManager, IEventAggregator eventAggregator)
{
_particlesManager = particlesManager;
_ideaManager = ideaManager;
_relationManager = relationManager;
_blockManager = blockManager;
_eventAggregator = eventAggregator;
AddParticleVm = new AddParticleViewViewModel(_particlesManager);
SelectIdea1Command = new DelegateCommand(() =>
{
var dlg = new SelectTagDlg(typeof (Idea));
var res = dlg.ShowDialog();
if (res.HasValue && res.Value && dlg.Id.HasValue)
{
_idea1 = _ideaManager.GetIdeaById(dlg.Id.Value);
Idea1Caption = _idea1.Caption;
OnPropertyChanged("Idea1Caption");
}
OkCommand.RaiseCanExecuteChanged();
});
SelectIdea2Command = new DelegateCommand(() =>
{
var dlg = new SelectTagDlg(typeof (Idea));
var res = dlg.ShowDialog();
if (res.HasValue && res.Value && dlg.Id.HasValue)
{
_idea2 = _ideaManager.GetIdeaById(dlg.Id.Value);
Idea2Caption = _idea2.Caption;
OnPropertyChanged("Idea2Caption");
}
OkCommand.RaiseCanExecuteChanged();
});
AddRelationTypeCommand = new DelegateCommand<RoutedEventArgs>(e =>
{
var text = ((ButtonEdit) e.Source).Text;
var rt = _relationManager.AddRelationType(text);
var relationDto = new RelationTypeDto() {Id = rt.Id, Name = text};
Relations.Add(relationDto);
Relation = relationDto;
});
OkCommand = new DelegateCommand<Window>(wnd =>
{
var relation = _relationManager.CreateRelation(Relation.Id, _idea1.Id, _idea2.Id);
if (AddParticleVm.AddParticle)
if (AddParticleVm.UseNewParticle)
{
var particle = _particlesManager.CreateParticle(AddParticleVm.NewParticle.Material,
AddParticleVm.NewParticle.Begin, AddParticleVm.NewParticle.End);
_blockManager.AddParticleToBlock(relation, particle);
}
else if (AddParticleVm.UseExistParticle && AddParticleVm.ExistParticle.HasValue)
{
var particle = _particlesManager.GetParticleById(AddParticleVm.ExistParticle.Value);
_blockManager.AddParticleToBlock(relation, particle);
}
_eventAggregator.GetEvent<BlockAddedEvent>().Publish(relation.Id);
wnd.DialogResult = true;
wnd.Close();
}, wnd => Relation != null && _idea1 != null && _idea2 != null);
Relations =
new ObservableCollection<RelationTypeDto>(
_relationManager.GetRelationTypes()
.Select(rt => new RelationTypeDto() {Id = rt.Id, Name = rt.Caption}));
}
public TransactionBlocksController(IBlockManager blockManager)
{
this.blockManager = blockManager;
}
public BlockGenerator(IBlockManager blockManager, BlockBehavior blockPrefab)
{
this.blockManager = blockManager;
this.blockPrefab = blockPrefab;
}
