public static void Process(LoadingComplete packet)
{
PlayerManager manager = InstanceKeeper.playerManager;
manager.PlayerLoadingFinished(packet.userName);
InstanceKeeper.playerManager = manager;
}
protected void FinishedLoading(bool successful)
{
IsLoading = false;
if (LoadingComplete != null)
{
LoadingComplete.Invoke(this, EventArgs.Empty);
}
}
public void OnLoad()
{
Bounds = _gameWindow.Bounds;
_sceneManager.OnLoad();
_renderer.OnLoad();
_renderer.SetViewPort(_gameWindow.ClientSize.Width, _gameWindow.ClientSize.Height);
_gameWindow.Title = _sceneManager.Scene.GetType().Name;
LoadingComplete?.Invoke(this, null);
}
public void SendLoadingComplete()
{
WriteLog.Verbose("Sending loading complete message to server");
LoadingComplete completePacket = new LoadingComplete();
completePacket.Generate(true, userName);
// GamePacket mainPacket = new GamePacket();
// mainPacket.Generate("LoadingComplete", null, completePacket);
ZeroGPacket packet = PacketGenerator.Generate("LoadingComplete", completePacket);
gClient.Send(packet, LiteNetLib.DeliveryMethod.ReliableOrdered);
}
public void Process(ZeroGPacket packet, NetPeer peer)
{
GamePacket origPacket = PacketGenerator.Decompile(packet);
if (packet.PacketType == "LoadingComplete" && (origPacket.GetType() == typeof(LoadingComplete)))
{
LoadingComplete newPacket = (LoadingComplete)origPacket;
// Console.WriteLine("Player " + newPacket.userName + " has set loading complete status to " + newPacket.isComplete);
LoadingCompleteProcessor.Process(newPacket);
}
else if (packet.PacketType == "ClientInfo" && (origPacket.GetType() == typeof(ClientInfo)))
{
ClientInfo newPacket = (ClientInfo)origPacket;
ClientInfoProcessor.Process(newPacket, peer.Id);
}
else if (packet.PacketType == "PlayerPosition" && (origPacket.GetType() == typeof(PlayerPosition)))
{
PlayerPositionProcessor.Process(packet, peer);
}
}
public override void OnLoadingComplete(ILevelInfo pLevel)
{
LoadingComplete?.Invoke(new EventArgs <ILevelInfo>(pLevel));
}
protected void OnLoadingComplete()
{
LoadingComplete?.Invoke(this, new EventArgs());
}
/// <summary>
/// Invoked by the corresponding component to indicate that it has completed loading
/// </summary>
public void OnLoadingComplete()
{
IsLoaded = true;
LoadingComplete?.Invoke(this, new EventArgs());
}
public TodoItemsViewModel()
{
TodoList = new ObservableCollection <TodoItem>();
AddTodoCommand = new RelayCommand(() =>
{
TodoList.Add(new TodoItem($"Neues ToDo {TodoItem.LastID + 2}", "...", DateTime.Now + TimeSpan.FromDays(1)));
SelectedItem = TodoList[TodoList.Count - 1];
DeleteTodoCommand.OnCanExecuteChanged();
});
DeleteTodoCommand = new RelayCommand(() =>
{
TodoList.Remove(SelectedItem);
DeleteTodoCommand.OnCanExecuteChanged();
},
() => SelectedItem != null
);
NextTodoCommand = new RelayCommand(() =>
{
if (TodoList.IndexOf(SelectedItem) < TodoList.Count - 1)
{
SelectedItem = TodoList[TodoList.IndexOf(SelectedItem) + 1];
}
else
{
SelectedItem = TodoList[0];
}
});
PreviewTodoCommand = new RelayCommand(() =>
{
if (TodoList.IndexOf(SelectedItem) > 0)
{
SelectedItem = TodoList[TodoList.IndexOf(SelectedItem) - 1];
}
else
{
SelectedItem = TodoList.Last();
}
});
SaveTodosCommand = new RelayCommand(() =>
{
TodoStorageService.SaveTodos();
});
ToggleFavoriteCommand = new RelayCommand <object>(HandleNotifications);
Task.Factory.StartNew(async() =>
{
try
{
await TodoStorageService.LoadTodos();
await Task.Delay(500);
}
catch (Exception exp)
{
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
NoSelectionText = exp.Message;
LoadingComplete?.Invoke(this, EventArgs.Empty);
});
return;
}
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
this.TodoList = TodoItemManager.ItemList;
NoSelectionText = TodoList.Count > 0 ? "Wähle ein Todo aus oder erstelle ein Neues!" : "Erstelle dein erstes Todo!";
LoadingComplete?.Invoke(this, EventArgs.Empty);
});
});
}
public void Load()
{
foreach (var set in DeserializeSets())
{
for (int i = 0; i < set.Cards.Count; i++)
{
var card = set.Cards[i];
card.Set = set;
card.Id = CardId.Generate(card);
preProcessCard(card);
}
for (int i = set.Cards.Count - 1; i >= 0; i--)
{
if (set.Cards[i].Remove)
{
set.Cards.RemoveAt(i);
}
}
// after preProcessCard, to have NameNormalized field set non empty
set.CardsByName = set.Cards.GroupBy(_ => _.NameNormalized)
.ToDictionary(
gr => gr.Key,
gr => gr.ToList(),
Str.Comparer);
foreach (var card in set.Cards)
{
CardsById[card.Id] = card;
CardsByScryfallId[card.ScryfallId] = card;
}
for (int i = 0; i < set.Cards.Count; i++)
{
postProcessCard(set.Cards[i]);
}
ImageNameCalculator.CalculateImageNames(set, Patch);
lock (SetsByCode)
SetsByCode.Add(set.Code, set);
lock (Cards)
foreach (var card in set.Cards)
{
Cards.Add(card);
}
SetAdded?.Invoke();
}
CardsByName = Cards.GroupBy(_ => _.NameNormalized)
.ToDictionary(
gr => gr.Key,
// card_by_name_sorting
gr => gr.OrderByDescending(_ => _.ReleaseDate).ToList(),
Str.Comparer);
CardsByMultiverseId = Cards
.Where(c => c.MultiverseId.HasValue)
.GroupBy(c => c.MultiverseId.Value)
.ToDictionary(gr => gr.Key, gr => (IList <Card>)gr.ToList());
for (int i = 0; i < Cards.Count; i++)
{
var card = Cards[i];
card.IndexInFile = i;
card.Namesakes = CardsByName[card.NameNormalized]
.Where(c => c != card)
.OrderByDescending(c => c.ReleaseDate)
.ToArray();
}
patchLegality();
IsLoadingComplete = true;
LoadingComplete?.Invoke();
// release RAM
_defaultSetsContent = null;
Patch = null;
Cards.Capacity = Cards.Count;
foreach (var namesakeList in CardsByName.Values)
{
namesakeList.Capacity = namesakeList.Count;
}
}
public void Load()
{
var serializer = new JsonSerializer();
Stream stream = new MemoryStream(_streamContent);
using (stream)
using (var stringReader = new StreamReader(stream))
using (var jsonReader = new JsonTextReader(stringReader))
{
jsonReader.Read();
while (true)
{
jsonReader.Read();
if (jsonReader.TokenType == JsonToken.EndObject)
{
// sets are over, all json was read
break;
}
var setCode = (string)jsonReader.Value;
// skip set name
jsonReader.Read();
if (!FilterSetCode(setCode))
{
jsonReader.Skip();
continue;
}
var set = serializer.Deserialize <Set>(jsonReader);
for (int i = 0; i < set.Cards.Count; i++)
{
var card = set.Cards[i];
card.Set = set;
preProcessCard(card);
}
for (int i = set.Cards.Count - 1; i >= 0; i--)
{
if (set.Cards[i].Remove)
{
set.Cards.RemoveAt(i);
}
}
// after preProcessCard, to have NameNormalized field set non empty
set.CardsByName = set.Cards.GroupBy(_ => _.NameNormalized)
.ToDictionary(
gr => gr.Key,
gr => gr.ToList(),
Str.Comparer);
lock (SetsByCode)
SetsByCode.Add(set.Code, set);
lock (Cards)
foreach (var card in set.Cards)
{
Cards.Add(card);
}
foreach (var card in set.Cards)
{
CardsById[card.Id] = card;
}
SetAdded?.Invoke();
}
}
CardsByName = Cards.GroupBy(_ => _.NameNormalized)
.ToDictionary(
gr => gr.Key,
// card_by_name_sorting
gr => gr.OrderByDescending(_ => _.ReleaseDate).ToList(),
Str.Comparer);
for (int i = 0; i < Cards.Count; i++)
{
var card = Cards[i];
card.IndexInFile = i;
card.Namesakes = CardsByName[card.NameNormalized]
.Where(c => c != card)
.OrderByDescending(c => c.ReleaseDate)
.ToArray();
}
patchLegality();
IsLoadingComplete = true;
LoadingComplete?.Invoke();
// release RAM
_streamContent = null;
_patch = null;
Cards.Capacity = Cards.Count;
}
public void Load()
{
var serializer = new JsonSerializer();
Stream stream = new MemoryStream(_streamContent);
using (stream)
using (var stringReader = new StreamReader(stream))
using (var jsonReader = new JsonTextReader(stringReader))
{
jsonReader.Read();
while (true)
{
// пропустить имя сета
jsonReader.Read();
if (jsonReader.TokenType == JsonToken.EndObject)
{
// сеты кончились, весь json прочитан
break;
}
// пропустить имя сета
jsonReader.Read();
var set = serializer.Deserialize <Set>(jsonReader);
for (int i = 0; i < set.Cards.Count; i++)
{
var card = set.Cards[i];
card.Set = set;
preProcessCard(card);
}
for (int i = set.Cards.Count - 1; i >= 0; i--)
{
if (set.Cards[i].Remove)
{
set.Cards.RemoveAt(i);
}
}
// после preProcessCard, чтобы было заполено поле NameNormalized
set.CardsByName = set.Cards.GroupBy(_ => _.NameNormalized)
.ToDictionary(
gr => gr.Key,
gr => gr.ToList(),
Str.Comparer);
lock (SetsByCode)
SetsByCode.Add(set.Code, set);
lock (Cards)
foreach (var card in set.Cards)
{
Cards.Add(card);
}
foreach (var card in set.Cards)
{
CardsById[card.Id] = card;
}
SetAdded?.Invoke();
}
}
CardsByName = Cards.GroupBy(_ => _.NameNormalized)
.ToDictionary(
gr => gr.Key,
// card_by_name_sorting
gr => gr.OrderByDescending(_ => _.ReleaseDate).ToList(),
Str.Comparer);
for (int i = 0; i < Cards.Count; i++)
{
Cards[i].IndexInFile = i;
}
patchLegality();
IsLoadingComplete = true;
LoadingComplete?.Invoke();
// освободить память
_streamContent = null;
_patch = null;
Cards.Capacity = Cards.Count;
}
