/// <summary>
/// Method <c> RestartGame</c> Restarts the game, setting all state to default,
/// and clears all items that would be bound to the gui.
/// </summary>
public void RestartGame()
{
// reset game variables
_timeInterval = 500;
_gameOver = false;
_paused = false;
PauseMessage = "";
Score = 0;
Level = 1;
// clear collections
Blocks.Clear();
NextBlock.Clear();
HeldBlock.Clear();
GameBoard.ClearGrid();
_timer.Interval = new TimeSpan(0, 0, 0, 0, _timeInterval);
// create shapes
_shape = _shapeFactory.BuildRandomShape();
_nextShape = _shapeFactory.BuildRandomShape();
NextBlock.AddRange(_nextShape.ShapeBlocks);
Blocks.AddRange(_shape.ShapeBlocks);
_timer.Start();
}
public void Load()
{
if (_load)
{
return;
}
_load = true;
Blocks.Clear();
TorchBase.Instance.Invoke(() =>
{
foreach (var block in Grid.GetFatBlocks().Where(b => b is IMyTerminalBlock))
{
Blocks.Add(new BlockViewModel((IMyTerminalBlock)block, Tree));
}
Grid.OnBlockAdded += Grid_OnBlockAdded;
Grid.OnBlockRemoved += Grid_OnBlockRemoved;
Tree.ControlDispatcher.BeginInvoke(() =>
{
Blocks.Sort(b => b.Block.CustomName);
});
});
}
public void PrepareMesher()
{
_opaqueCollidedMesh.ClearData();
_translucentPassableMesh.ClearData();
_opaquePassableMesh.ClearData();
Blocks.Clear();
}
///<summary>МЕТОД Инициализация отчета</summary>
/// <param name="pNodes">Ветка</param>
public override VirtualOtchet MET_Inizial(VirtualNodes pNodes)
{
// Если нужно формировать отчет
if (PROP_NewCreate)
{
base.MET_Inizial(pNodes);
// Список элементов
PRO_PoleHistory = new Queue();
// Чистим
Blocks.Clear();
// Формируем отчет
MET_Otchet();
// Добавляем последний параграф в блок
Blocks.Add(PRO_Paragraph);
// Помечаем, что больше его формировать не надо
PROP_NewCreate = false;
// Если всего один отчет, то сразу же его показываем
if (PRO_PoleHistory.Count == 1)
{
UserPole_History _Pole = (UserPole_History)PRO_PoleHistory.Peek();
// Окрываем эспандер
_Pole.PROP_IsExpanded = true;
}
}
return(this);
}
public void Clear()
{
Blocks.Clear();
Config.Clear();
ElimsCommitHistory.Clear();
ElimsData.Clear();
ElimsGameSpecific.Clear();
ElimsGameSpecificHistory.Clear();
ElimsResults.Clear();
ElimsScores.Clear();
ElimsScoresHistory.Clear();
LeagueConfig.Clear();
LeagueHistory.Clear();
LeagueInfo.Clear();
LeagueMeets.Clear();
Match.Clear();
MatchSchedule.Clear();
Quals.Clear();
QualsCommitHistory.Clear();
QualsData.Clear();
QualsGameSpecific.Clear();
QualsGameSpecificHistory.Clear();
QualsResults.Clear();
QualsScores.Clear();
QualsScoresHistory.Clear();
ScheduleDetail.Clear();
ScheduleStation.Clear();
Team.Clear();
TeamRanking.Clear();
}
private void BuildLanguageBlockCollection()
{
var tokenizer = new MdTokenizer();
var tokens = tokenizer.Tokenize(TextBuffer.CurrentSnapshot.GetText());
var rCodeTokens = tokens.Where(t => t.TokenType == MarkdownTokenType.Code);
// TODO: incremental updates
Blocks.Clear();
_separators.Clear();
foreach (var t in rCodeTokens)
{
// Verify that code block is properly terminated.
// If not, it ends at the end of the buffer.
_separators.Add(new TextRange(t.Start, 5));
if (t.IsWellFormed)
{
Blocks.Add(TextRange.FromBounds(t.Start + 3, t.End - 3));
_separators.Add(new TextRange(t.End - 3, 3));
}
else
{
Blocks.Add(TextRange.FromBounds(t.Start + 3, t.End));
}
}
}
// Reloads the level and reinitializes Mario to his default state.
public void Reset()
{
Enemies.Clear();
Blocks.Clear();
Pipes.Clear();
Coins.Clear();
Checkpoints.Clear();
Flagpoles.Clear();
levelData.Clear();
InvisibleBarrier = new InvisibleBarrier(Vector2.Zero);
CoinRoomPosition = Vector2.Zero;
DynamicObjects.Clear();
StaticObjects.Clear();
PowerUpState = false;
Mario.Instance.ResetPlayer();
SoundManager.Instance.gameOverPlayOnce = true;
levelData = ParseLevelCSV(fileName);
BuildLevel(levelData);
}
public void InitializeGrid(int rows = 10, int cols = 18)
{
containerGrid.Children.Clear();
containerGrid.RowDefinitions.Clear();
containerGrid.ColumnDefinitions.Clear();
Rows = rows;
Columns = cols;
for (int i = 0; i < Rows; i++)
{
containerGrid.RowDefinitions.Add(new RowDefinition {
Height = new GridLength(GridLength)
});
}
for (int i = 0; i < Columns; i++)
{
containerGrid.ColumnDefinitions.Add(new ColumnDefinition {
Width = new GridLength(GridLength)
});
}
Blocks.Clear();
var matrix = new bool[Rows, Columns];
var areas = Depart(Rows, Columns);
foreach (var area in areas)
{
FindLargestBlock(area, matrix, out var block);
Blocks.Add(block);
}
LoopRestBlocks(matrix);
}
public BlocksViewModel(NewBlockProcessingService newBlockProcessingService)
{
_newBlockProcessingService = newBlockProcessingService;
MessageBus.Current.Listen <UrlChanged>().Subscribe(x =>
{
lock (_lockingObject)
{
Loading = true;
Blocks.Clear();
}
}
);
_newBlockProcessingService.Blocks.Connect().Subscribe(blockChanges =>
{
lock (_lockingObject)
{
Loading = true;
Blocks.Edit(_ =>
{
Blocks.Clear();
foreach (var block in _newBlockProcessingService.Blocks.Items)
{
Blocks.AddOrUpdate(new BlockViewModel(block));
}
});
Loading = false;
}
}
);
}
/// <summary>
/// Occurs when <see cref="TokensSource"/> property changes.
/// </summary>
protected virtual async void OnTokensSourceChanged(string Value)
{
if (!TokensChangeHandled)
{
TextChangeHandled = true;
await Dispatcher.BeginInvoke(() =>
{
var d = TokenDelimiter.ToString();
//Check to see if delimiter occurs more than once in any one place.
var Temp = Regex.Replace(Value, d + "+", d);
//If so, correct it
if (Temp != Value)
{
TokensChangeHandled = true;
TokensSource = Temp;
TokensChangeHandled = false;
}
Tokens.Clear();
Blocks.Clear();
if (Value?.ToString().IsEmpty() == false)
{
var p = new Paragraph();
Tokenizer?.Tokenize(Value, TokenDelimiter)?.ForEach(Token => p.Inlines.Add(GenerateInline(Token)));
Blocks.Add(p);
}
});
TextChangeHandled = false;
}
}
protected internal virtual int SaveBlocks(ICollectionOnDisk parent, int maxBlocks, bool clear)
{
int r = 0;
if (parent != null)
{
if (!_inSaveBlocks && !DelaySaveBlocks)
{
_inSaveBlocks = true;
r = Blocks.Count;
if (Blocks.Count >= maxBlocks)
{
WriteBlocksToDisk(parent, Blocks, clear);
if (DataBlockDriver.BlockRecycler == null)
{
((DataBlockDriver)DataBlockDriver).BlockRecycler =
new DataBlockRecycler(File.Profile.MaxInMemoryBlockCount);
((DataBlockRecycler)((DataBlockDriver)DataBlockDriver).BlockRecycler).PreAllocateBlocks(DataBlockSize);
}
DataBlockDriver.BlockRecycler.Recycle(Blocks.Values);
Blocks.Clear();
}
_inSaveBlocks = false;
}
}
return(r);
}
void ResetBlocks()
{
var first = Blocks.First();
Blocks.Clear();
Blocks.Add(first);
}
public void Reset(Floor floor)
{
this.floor = floor;
Blocks.Clear();
activeBlock = CreateBlock();
HasDied = false;
}
private void BuildLanguageBlockCollection()
{
var tokenizer = new MdTokenizer();
var tokens = tokenizer.Tokenize(TextBuffer.CurrentSnapshot.GetText());
var rCodeTokens = tokens.Where(t => {
var mct = t as MarkdownCodeToken;
return(mct != null && mct.LeadingSeparatorLength > 1);
});
// TODO: incremental updates
Blocks.Clear();
_separators.Clear();
foreach (MarkdownCodeToken t in rCodeTokens)
{
// Verify that code block is properly terminated.
// If not, it ends at the end of the buffer.
var text = t.GetText(TextBuffer.CurrentSnapshot);
_separators.Add(new TextRange(t.Start, t.LeadingSeparatorLength)); // ```r{ or `r
if (t.IsWellFormed)
{
// Count backticks
Blocks.Add(TextRange.FromBounds(t.Start + t.LeadingSeparatorLength, t.End - t.TrailingSeparatorLength));
_separators.Add(new TextRange(t.End - t.TrailingSeparatorLength, t.TrailingSeparatorLength));
}
else
{
Blocks.Add(TextRange.FromBounds(t.Start + t.LeadingSeparatorLength, t.End));
}
}
}
public async Task LoadBlocks()
{
IsBusy = true;
IsGridVisible = false;
try
{
var blocks = await Task.Run(() => _blockRepository.LoadBlocks());
Blocks.Clear();
foreach (var block in blocks)
{
Blocks.Add(CreateBlockViewModel(block));
}
IsGridVisible = true;
}
catch (Exception)
{
MessageBox.Show(Resources.ErrorLoadingBlocks, Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
Blocks.Clear();
}
finally
{
IsBusy = false;
}
}
///<summary>МЕТОД Инициализация отчета</summary>
/// <param name="pNodes">Ветка</param>
public override VirtualOtchet MET_Inizial(VirtualNodes pNodes)
{
// Если нужно формировать отчет
if (PROP_NewCreate)
{
base.MET_Inizial(pNodes);
PROP_Prefix = "kdl";
// Ветка
PROP_Nodes = pNodes;
// Чистим блок
Blocks.Clear();
// Если есть заполенный протокол
if (PROP_Nodes.PROP_shaPresenceProtokol)
{
MET_Otchet(); // Формируем отчет
}
else
{
MET_NoOtchet(); // Отчет не заполен
}
// Добавляем последний параграф в блок
Blocks.Add(PRO_Paragraph);
// Помечаем, что больше его формировать не надо
PROP_NewCreate = false;
}
// Фон
MET_Background();
return(this);
}
private void Update()
{
Blocks.Clear();
foreach (var item in model.Blocks)
{
Blocks.Add(new BlockModel(item));
}
}
private void GenerateContent(DataTemplate template)
{
Blocks.Clear();
if (template != null)
{
FrameworkContentElement element = Helpers.LoadDataTemplate(template);
Blocks.Add((Block)element);
}
}
public void Clear()
{
Dictionary <uint, Block> .ValueCollection blocks = Blocks.Values;
foreach (Block block in blocks)
{
GameObject.Destroy(block.Representation.gameObject);
}
Blocks.Clear();
}
private void GenerateContent(DataTemplate itemsPanel, DataTemplate itemTemplate, IEnumerable itemsSource)
{
Blocks.Clear();
if (itemTemplate != null && itemsSource != null)
{
FrameworkContentElement panel = null;
foreach (object data in itemsSource)
{
if (panel == null)
{
if (itemsPanel == null)
{
panel = this;
}
else
{
FrameworkContentElement p = Helpers.LoadDataTemplate(itemsPanel);
if (!(p is Block))
{
throw new Exception("ItemsPanel must be a block element");
}
Blocks.Add((Block)p);
panel = Attached.GetItemsHost(p);
if (panel == null)
{
throw new Exception("ItemsHost not found. Did you forget to specify Attached.IsItemsHost?");
}
}
}
FrameworkContentElement element = Helpers.LoadDataTemplate(itemTemplate);
element.DataContext = data;
Helpers.UnFixupDataContext(element);
if (panel is Section)
{
((Section)panel).Blocks.Add(Helpers.ConvertToBlock(data, element));
}
else if (panel is TableRowGroup)
{
((TableRowGroup)panel).Rows.Add((TableRow)element);
}
else if (panel is List)
{
(panel as List).ListItems.Add((ListItem)element);
}
else
{
throw new Exception(String.Format("Don't know how to add an instance of {0} to an instance of {1}", element.GetType(), panel.GetType()));
}
}
}
}
public void Populate(Guid guid)
{
Blocks.Clear();
var v = _intervalBlockStorage.Get(guid);
foreach (var block in v.Blocks)
{
AddBlock(block.Key, block.Value);
}
}
/// <summary>МЕТОД Формируем отчет</summary>
protected override void MET_Otchet()
{
Frame _Frame = new Frame(); // фрейм, для мед. назначений
UserPage_Registration _Page = new UserPage_Registration(); // создаем лист регистратуры
_Frame.Navigate(_Page); // помещаем лист мед. назначений на фрейм
PRO_Paragraph = new Paragraph();
PRO_Paragraph.Inlines.Add(_Frame);
Blocks.Clear();
Blocks.Add(PRO_Paragraph);
}
private void OrderBlocks(bool orderByNumber)
{
Blocks.Clear();
var orderedBlocks = Blocks.OrderBy(b => orderByNumber ? b.Number : b.Size).ToList();
for (int newIndex = 0; newIndex < orderedBlocks.Count; newIndex++)
{
int oldIndex = Blocks.IndexOf(orderedBlocks[newIndex]);
Blocks.Move(oldIndex, newIndex);
}
}
/// <summary>МЕТОД Формируем отчет</summary>
protected override void MET_Otchet()
{
PRO_Paragraph = new Paragraph();
Frame _Frame = new Frame();
UserPage_KartParacl _Page = new UserPage_KartParacl(); // создаем карту параклиники
_Frame.Navigate(_Page);
PRO_Paragraph.Inlines.Add(_Frame);
Blocks.Clear();
Blocks.Add(PRO_Paragraph);
}
public void Teardown()
{
Blocks.Clear();
OpenMinecraft.Entities.Entity.Cleanup();
OpenMinecraft.TileEntities.TileEntity.Cleanup();
Directory.Delete("mobs", true);
Directory.Delete("items", true);
Directory.Delete("blocks", true);
Environment.CurrentDirectory = mOldCwd;
Console.WriteLine("cd " + Environment.CurrentDirectory);
}
/// <summary>
/// Loads an assembler's queue into the Blocks dictionary.
/// </summary>
/// <param name="assembler"></param>
public void SetBlocksFromAssembler(IMyAssembler assembler)
{
var queue = new List <MyProductionItem>();
assembler.GetQueue(queue);
Blocks.Clear();
queue.ForEach(item => {
var blueprintId = item.BlueprintId.ToString();
var amount = (int)item.Amount;
Blocks.Add(blueprintId, amount);
});
}
/// <summary>Schedule a grid scan. It will happen over the course of several next ticks, depending on how large the grid is.</summary>
public void ScanGrid()
{
if (GroupFeed != null || BlockFeed != null)
{
return; //grid scan already in progress, ignore
}
GroupList.Clear();
PB.GridTerminalSystem.GetBlockGroups(GroupList);
GroupFeed = FeedList(GroupList, GroupScanTick).GetEnumerator();
Blocks.Clear();
PB.GridTerminalSystem.GetBlocks(Blocks);
BlockFeed = FeedList(Blocks, BlockFound).GetEnumerator();
Tick1 += RescanTick;
}
public ScriptPage Run()
{
Messages = new List <LogMessage>();
HasErrors = false;
blockLevel = 0;
Blocks.Clear();
ScriptBlockStatement frontMatter = null;
switch (CurrentParsingMode)
{
case ScriptMode.FrontMatter:
if (Current.Type != TokenType.CodeEnter)
{
LogError($"When [{CurrentParsingMode}] is enabled, expecting a {{ at the beginning of the text");
return(null);
}
// Parse the front matter
frontMatter = ParseBlockStatement(null);
break;
case ScriptMode.ScriptOnly:
inCodeSection = true;
break;
}
var page = Open <ScriptPage>();
ParseBlockStatement(page);
// Store the frontMatter if any
page.FrontMatter = frontMatter;
if (frontMatter != null)
{
FixRawStatementAfterFrontMatter(page);
}
if (lexer.HasErrors)
{
foreach (var lexerError in lexer.Errors)
{
Log(lexerError);
}
}
return(!HasErrors ? page : null);
}
private void BuildLanguageBlockCollection()
{
var tokenizer = new MdTokenizer();
var tokens = tokenizer.Tokenize(TextBuffer.CurrentSnapshot.GetText());
var rCodeTokens = tokens.Where(t => t.TokenType == MarkdownTokenType.Code);
// TODO: incremental updates
Blocks.Clear();
_separators.Clear();
foreach (var t in rCodeTokens)
{
Blocks.Add(new TextRange(t.Start + 3, t.Length - 6));
_separators.Add(new TextRange(t.Start, 5));
_separators.Add(new TextRange(t.End - 3, 3));
}
}
///<summary>МЕТОД Инициализация отчета</summary>
/// <param name="pNodes">Ветка</param>
public override VirtualOtchet MET_Inizial(VirtualNodes pNodes)
{
// Если нужно формировать отчет
if (PROP_NewCreate)
{
base.MET_Inizial(pNodes);
// Чистим блок
Blocks.Clear();
// Формируем отчет
MET_Otchet();
// Добавляем последний параграф в блок
Blocks.Add(PRO_Paragraph);
// Помечаем, что больше его формировать не надо
PROP_NewCreate = false;
}
return(this);
}
