public ProcGenerator()
:base( ProcType.GENERATOR )
{
NextIfs = new ObservableCollection<ProcFind.RegItem>();
StopIfs = new ObservableCollection<ProcFind.RegItem>();
Urls = new ObservableHashSet<string>();
}
public void RemoveWhere() {
var names = new ObservableHashSet<string>(_names);
names.CollectionChanged += (sender, args) => Console.WriteLine(args.Action);
for (int i = names.Count; i > 0; i--) {
int length = i;
names.RemoveWhere(n => n.Length > length);
}
Assert.AreEqual(0, names.Count);
}
public Tuple()
{
LeftHandSide = new VulcanCollection<Definition>();
RightHandSide = new VulcanCollection<Use>();
DefinedIdentifiers = new ObservableHashSet<Identifier>();
UsedIdentifiers = new ObservableHashSet<Identifier>();
ExternalDefinitions = new ObservableDictionary<Identifier, ObservableHashSet<Definition>>();
LastIdentifierDefinition = new ObservableDictionary<Identifier, Definition>();
}
public void WhenConstructed_ThenInitialized() {
// Arrange
// Act
var actual = new ObservableHashSet<int>();
// Assert
Assert.IsNotNull(actual);
Assert.AreEqual(0, actual.Count);
Assert.IsNotNull(actual.Comparer);
}
public void WhenAdd_ThenCountUpdated() {
// Arrange
var target = new ObservableHashSet<int>();
// Act
target.Add(5);
var actual = target.Count;
// Assert
Assert.AreEqual(1, actual);
}
public void Items_set_in_the_binding_list_are_replaced_in_the_ObservableHashSet()
{
var item = new ListElement(4);
var oc = new ObservableHashSet <ListElement> {
3, 1, item, 1, 5, 9
};
var obbl = new ObservableBackedBindingList <ListElement>(oc);
var newItem = new ListElement(7);
obbl[2] = newItem;
Assert.True(oc.Contains(newItem));
Assert.False(oc.Contains(item));
}
public void RemoveWhereConcurrent() {
var names = new ObservableHashSet<string>(_names);
names.CollectionChanged += (sender, args) => Console.WriteLine(args.Action);
for (int i = names.Count; i > 0; i--) {
int length = i;
var task = Task.Factory.StartNew(() => {
names.Add("Bob");
names.RemoveWhere(n => n.Equals("Bob"));
});
names.RemoveWhere(n => n.Length > length);
task.WaitWithPumping();
}
Assert.AreEqual(0, names.Count);
}
public void Contains_works()
{
var testData = CreateTestData();
var hashSet = new ObservableHashSet <int>(testData);
foreach (var item in testData)
{
Assert.True(hashSet.Contains(item));
}
foreach (var item in CreateTestData(1000, 10000).Except(testData))
{
Assert.False(hashSet.Contains(item));
}
}
private async Task DeleteCollectionAsync(SMCollection collection)
{
var res = await Forge.Forms.Show.Window().For(new Confirmation("Are you sure ?")).ConfigureAwait(true);
if (res.Model.Confirmed)
{
// ObservableHashSet does not have index, which results in an exception when notifying for removal
var tmpCollections = SavedCollections;
SavedCollections = null;
tmpCollections.Remove(collection);
SaveConfig();
SavedCollections = tmpCollections;
}
}
public void WhenAdd_ThenRaisesCountPropertyChanged() {
// Arrange
var target = new ObservableHashSet<int>();
bool wasEventRaised = false;
target.PropertyChanged += (s, e) => {
if (e.PropertyName == ObservableHashSet<int>.PropertyNames.Count) {
wasEventRaised = true;
}
};
// Act
target.Add(5);
// Assert
Assert.IsTrue(wasEventRaised);
}
public void Items_cleared_in_the_ObservableHashSet_are_cleared_in_the_binding_list()
{
var oc = new ObservableHashSet <ListElement>
{
3,
1,
4,
1,
5,
9
};
var obbl = new ObservableBackedBindingList <ListElement>(oc);
oc.Clear();
Assert.Empty(obbl);
}
public Group(Room room, Node defaultNode = null, Group parentGroup = null, string Name = "", bool Spawnable = true, ObservableHashSet<Node> entities = null)
{
if (parentGroup != null) room = parentGroup.room;
this.room = room ?? OrbIt.game.room;
GroupId = -1;
this.defaultNode = defaultNode ?? this.room.defaultNode;
this.entities = entities ?? new ObservableHashSet<Node>();
this.inherited = new ObservableHashSet<Node>();
this.fullSet = new ObservableHashSet<Node>();
if (entities != null)
{
foreach (Node e in entities)
{
fullSet.Add(e);
}
}
this.parentGroup = parentGroup;
//this.groupState = groupState;
this.Spawnable = Spawnable;
this.childGroups = new Dictionary<string, Group>();
this.entities.CollectionChanged += entities_CollectionChanged;
this.inherited.CollectionChanged += entities_CollectionChanged;
if (Name.Equals(""))
{
this.GroupId = GroupNumber;
Name = "Group" + GroupNumber; //maybe a check that the name is unique
GroupNumber++;
}
this.Name = Name;
groupPath = new List<Group>();
if (parentGroup != null)
{
parentGroup.AddGroup(this.Name, this);
Group g = parentGroup;
while (g != null)
{
groupPath.Add(g);
g = g.parentGroup;
}
}
}
public void Items_cleared_from_the_binding_list_are_cleared_from_the_ObservableHashSet()
{
var oc = new ObservableHashSet <ListElement>
{
3,
1,
4,
1,
5,
9
};
var obbl = new ObservableBackedBindingList <ListElement>(oc);
obbl.Clear();
Assert.Equal(0, oc.Count);
}
public void WhenAdd_ThenRaisesCollectionChanged() {
// Arrange
var target = new ObservableHashSet<int>();
bool wasEventRaised = false;
target.CollectionChanged += (s, e) => {
if (e.Action == NotifyCollectionChangedAction.Add && e.NewItems.Contains(5)) {
wasEventRaised = true;
}
};
// Act
target.Add(5);
// Assert
Assert.IsTrue(wasEventRaised);
}
public void Can_remove()
{
var hashSet = new ObservableHashSet <string> {
"Palmer", "Carmack"
};
var countChanging = 0;
var countChanged = 0;
var collectionChanged = 0;
var currentCount = 2;
var countChange = -1;
var removing = new string[0];
hashSet.PropertyChanging += (s, a) => AssertCountChanging(hashSet, s, a, currentCount, ref countChanging);
hashSet.PropertyChanged += (s, a) => AssertCountChanged(hashSet, s, a, ref currentCount, countChange, ref countChanged);
hashSet.CollectionChanged += (s, a) =>
{
Assert.Equal(NotifyCollectionChangedAction.Remove, a.Action);
Assert.Equal(removing, a.OldItems.OfType <string>());
Assert.Null(a.NewItems);
collectionChanged++;
};
removing = new[] { "Palmer" };
Assert.True(hashSet.Remove("Palmer"));
Assert.Equal(1, countChanging);
Assert.Equal(1, countChanged);
Assert.Equal(1, collectionChanged);
Assert.Equal(new[] { "Carmack" }, hashSet);
removing = new[] { "Carmack" };
Assert.True(hashSet.Remove("Carmack"));
Assert.Equal(2, countChanging);
Assert.Equal(2, countChanged);
Assert.Equal(2, collectionChanged);
Assert.Empty(hashSet);
Assert.False(hashSet.Remove("Palmer"));
Assert.Equal(2, countChanging);
Assert.Equal(2, countChanged);
Assert.Equal(2, collectionChanged);
Assert.Empty(hashSet);
}
public void RemoveWhereConcurrent()
{
var names = new ObservableHashSet <string>(_names);
names.CollectionChanged += (sender, args) => Console.WriteLine(args.Action);
for (int i = names.Count; i > 0; i--)
{
int length = i;
var task = Task.Factory.StartNew(() => {
names.Add("Bob");
names.RemoveWhere(n => n.Equals("Bob"));
});
names.RemoveWhere(n => n.Length > length);
task.WaitWithPumping();
}
Assert.AreEqual(0, names.Count);
}
public void Entry_handles_clear_as_replace_with_ObservableHashSet()
{
var item1 = new ChangedOnlyNotificationEntity();
var item2 = new ChangedOnlyNotificationEntity();
var collection = new ObservableHashSet <ChangedOnlyNotificationEntity> {
item1, item2
};
var testListener = SetupTestCollectionListener(collection);
collection.Clear();
Assert.Empty(collection);
Assert.Equal("RelatedCollection", testListener.CollectionChanged.Single().Item2.Name);
Assert.Empty(testListener.CollectionChanged.Single().Item3);
Assert.Same(item1, testListener.CollectionChanged.Single().Item4.First());
Assert.Same(item2, testListener.CollectionChanged.Single().Item4.Skip(1).Single());
}
public void Items_removed_from_the_binding_list_are_removed_from_the_ObservableHashSet()
{
var item = new ListElement(4);
var oc = new ObservableHashSet <ListElement>
{
3,
1,
item,
1,
5,
9
};
var obbl = new ObservableBackedBindingList <ListElement>(oc);
obbl.Remove(item);
Assert.DoesNotContain(item, oc);
}
public void Items_removed_by_index_from_the_binding_list_are_removed_from_the_ObservableHashSet()
{
var item = new ListElement(4);
var oc = new ObservableHashSet <ListElement>
{
3,
1,
item,
1,
5,
9
};
var obbl = new ObservableBackedBindingList <ListElement>(oc);
obbl.RemoveAt(2);
Assert.False(oc.Contains(item));
}
public void Can_add()
{
var hashSet = new ObservableHashSet <string>();
var countChanging = 0;
var countChanged = 0;
var collectionChanged = 0;
var currentCount = 0;
var countChange = 1;
var adding = new string[0];
hashSet.PropertyChanging += (s, a) => AssertCountChanging(hashSet, s, a, currentCount, ref countChanging);
hashSet.PropertyChanged += (s, a) => AssertCountChanged(hashSet, s, a, ref currentCount, countChange, ref countChanged);
hashSet.CollectionChanged += (s, a) =>
{
Assert.Equal(NotifyCollectionChangedAction.Add, a.Action);
Assert.Null(a.OldItems);
Assert.Equal(adding, a.NewItems.OfType <string>());
collectionChanged++;
};
adding = new[] { "Palmer" };
Assert.True(hashSet.Add("Palmer"));
Assert.Equal(1, countChanging);
Assert.Equal(1, countChanged);
Assert.Equal(1, collectionChanged);
Assert.Equal(new[] { "Palmer" }, hashSet);
adding = new[] { "Carmack" };
Assert.True(hashSet.Add("Carmack"));
Assert.Equal(2, countChanging);
Assert.Equal(2, countChanged);
Assert.Equal(2, collectionChanged);
Assert.Equal(new[] { "Carmack", "Palmer" }, hashSet.OrderBy(i => i));
Assert.False(hashSet.Add("Palmer"));
Assert.Equal(2, countChanging);
Assert.Equal(2, countChanged);
Assert.Equal(2, collectionChanged);
Assert.Equal(new[] { "Carmack", "Palmer" }, hashSet.OrderBy(i => i));
}
public void Items_removed_from_ObservableHashSet_are_removed_from_binding_list()
{
var item = new ListElement(4);
var oc = new ObservableHashSet <ListElement>
{
3,
1,
item,
1,
5,
9
};
var obbl = new ObservableBackedBindingList <ListElement>(oc);
oc.Remove(item);
Assert.False(obbl.Contains(item));
Assert.Equal(5, obbl.Count);
}
public void Adding_duplicate_item_to_the_ObservableHashSet_is_ignored()
{
var item = new ListElement(4);
var oc = new ObservableHashSet <ListElement>
{
3,
1,
item,
1,
5,
9
};
var obbl = new ObservableBackedBindingList <ListElement>(oc);
oc.Add(item);
Assert.Equal(6, obbl.Count);
Assert.Equal(1, obbl.Count(i => ReferenceEquals(i, item)));
}
public GraphNode(Graph <T> graph, T item)
{
Graph = graph;
Item = item;
IncomingEdges = new VulcanCollection <GraphEdge <T> >();
OutgoingEdges = new VulcanCollection <GraphEdge <T> >();
_dominates = new ObservableHashSet <GraphNode <T> >()
{
this
};
_dominatedBy = new ObservableHashSet <GraphNode <T> >()
{
this
};
_immediatelyDominates = new ObservableHashSet <GraphNode <T> >();
_dominanceFrontier = new ObservableHashSet <GraphNode <T> >();
_dominanceFrontierOf = new ObservableHashSet <GraphNode <T> >();
}
public MainViewModel()
{
Instance = this;
TextKeys = new Dictionary<string, TextKeyViewModel>();
LoadedCultureNames = new HashSet<string>();
DeletedCultureNames = new HashSet<string>();
RootTextKey = new TextKeyViewModel(null, false, null, this);
ProblemKeys = new ObservableHashSet<TextKeyViewModel>();
searchDc = DelayedCall.Create(UpdateSearch, 250);
SearchText = ""; // Change value once to set the clear button visibility
ClearViewHistory();
UpdateTitle();
FontScale = App.Settings.View.FontScale;
App.Settings.View.OnPropertyChanged(s => s.ShowSuggestions, UpdateSuggestionsLayout);
App.Settings.View.OnPropertyChanged(s => s.SuggestionsHorizontalLayout, UpdateSuggestionsLayout);
UpdateSuggestionsLayout();
}
public void WhenClear_ThenRaisesCollectionChanged() {
// Arrange
var target = new ObservableHashSet<int>();
target.Add(1);
target.Add(2);
target.Add(3);
bool wasEventRaised = false;
target.CollectionChanged += (s, e) => {
if (e.Action == NotifyCollectionChangedAction.Reset) {
wasEventRaised = true;
}
};
// Act
target.Clear();
// Assert
Assert.IsTrue(wasEventRaised);
}
/// <summary>
/// Updates the versions of all entities that are currently marked as modified.
/// </summary>
internal void UpdateVersions()
{
var versionEntries = new ObservableHashSet <PropertyEntry>();
foreach (EntityEntry entityEntry in ChangeTracker.Entries())
{
if (entityEntry.Entity is VersionedEntity versionedEntity)
{
var propertyEntry = entityEntry.Property(nameof(versionedEntity.Version));
var currentVersion = (long)propertyEntry.CurrentValue;
propertyEntry.CurrentValue = currentVersion + 1L;
versionEntries.Add(propertyEntry);
}
}
// Mark the updated versions as not being modified. This prevents the entity from being
// included in any subsequent SaveChanges call, unless one of its actual properties is
// updated.
foreach (PropertyEntry pe in versionEntries)
{
pe.IsModified = false;
}
}
public void Synchronizing_RollsBackTargetChangesPriorToSourceTick()
{
var source = new ObservableHashSet <string>();
var SourceSynchronizerRoot = new SourceSynchronizerRoot(source);
byte[] writeFullAndDispose = SourceSynchronizerRoot.WriteFullAndDispose();
var TargetSynchronizerRoot = new TargetSynchronizerRoot <ObservableHashSet <string> >(
writeFullAndDispose);
ObservableHashSet <string> target = TargetSynchronizerRoot.Reference;
target.Add("2");
TargetSynchronizerRoot.Clock.OwnTick = TimeSpan.FromMilliseconds(5);
//Set tick older than client tick
byte[] changes = SourceSynchronizerRoot.WriteChangesAndDispose().SetTick(TimeSpan.FromMilliseconds(6));
TargetSynchronizerRoot.Read(changes);
// Recently added item should be rolled back
Assert.Empty(target);
}
public void StartFollowActions(ObservableHashSet <FollowerUI> toFollow,
ObservableHashSet <FollowerUI> unFollow, Action <ActionPerformArgument> callback)
{
var args = new ActionPerformArgument
{
Total = toFollow.Count + unFollow.Count,
Performed = 0
};
foreach (var l in toFollow)
{
var task = _instaApi.FollowUserAsync(l.OtherUser.Pk);
task.GetAwaiter().OnCompleted(
() =>
{
args.Performed++;
if (!task.Result.Value.Following)
{
toFollow.Remove(l);
}
callback(args);
});
}
foreach (var l in unFollow)
{
var task = _instaApi.UnFollowUserAsync(l.OtherUser.Pk);
task.GetAwaiter().OnCompleted(
() => {
args.Performed++;
if (task.Result.Value.Following)
{
unFollow.Remove(l);
}
callback(args);
});
}
}
public void RefreshTasks(Browser browser)
{
var taskSet = new HashSet <Task>();
var taskLinks = TaskScraper.GetAllLinks(browser);
foreach (var link in taskLinks)
{
var task = XmlTaskDatabase.Instance.Tasks.FirstOrDefault(t => string.Equals(t.Link, link));
if (task == null)
{
task = TaskScraper.GetTaskInfo(link, browser);
}
else
{
TaskScraper.UpdateTaskInfo(task, browser);
}
taskSet.Add(task);
}
foreach (var task in taskSet)
{
if (XmlTaskDatabase.Instance.Tasks.Contains(task))
{
XmlTaskDatabase.Instance.Tasks.Remove(task);
}
XmlTaskDatabase.Instance.Tasks.Add(task);
}
XmlTaskDatabase.Instance.Save();
this.Tasks = new ObservableHashSet <Task>(XmlTaskDatabase.Instance.Tasks);
this.OnPropertyChanged("Tasks");
}
public void only_different_order_confirmations_can_be_added_to_hashset()
{
ObservableHashSet <OrderDeliveryConfirmation> confirmations =
new ObservableHashSet <OrderDeliveryConfirmation>(new OrderDeliveryConfirmationComparer());
Order o1 = new Order(1,
BrokerDateTime.Make(DateTime.Now),
"BP12345-RF-01",
"RTS-9.13_FT",
TradeAction.Buy,
OrderType.Limit,
10,
136000,
0);
OrderDeliveryConfirmation c1 =
new OrderDeliveryConfirmation(o1, BrokerDateTime.Make(DateTime.Now));
confirmations.Add(c1);
Assert.AreEqual(1, confirmations.Count);
Order o2 = new Order(2,
BrokerDateTime.Make(DateTime.Now),
"BP12345-RF-01",
"RTS-9.13_FT",
TradeAction.Sell,
OrderType.Limit,
10,
136000,
0);
OrderDeliveryConfirmation c2 =
new OrderDeliveryConfirmation(o2, BrokerDateTime.Make(DateTime.Now));
confirmations.Add(c2);
Assert.AreEqual(2, confirmations.Count);
}
public void Can_symetrical_except_with()
{
var hashSet = new ObservableHashSet <string> {
"Brendan", "Carmack", "Nate", "Palmer"
};
var countChanging = 0;
var countChanged = 0;
var collectionChanged = 0;
var currentCount = 4;
var countChange = -1;
var removing = new[] { "Carmack", "Palmer" };
var adding = new[] { "Abrash" };
hashSet.PropertyChanging += (s, a) => AssertCountChanging(hashSet, s, a, currentCount, ref countChanging);
hashSet.PropertyChanged += (s, a) => AssertCountChanged(hashSet, s, a, ref currentCount, countChange, ref countChanged);
hashSet.CollectionChanged += (s, a) =>
{
Assert.Equal(NotifyCollectionChangedAction.Replace, a.Action);
Assert.Equal(removing, a.OldItems.OfType <string>().OrderBy(i => i));
Assert.Equal(adding, a.NewItems.OfType <string>().OrderBy(i => i));
collectionChanged++;
};
hashSet.SymmetricExceptWith(new[] { "Carmack", "Palmer", "Abrash" });
Assert.Equal(1, countChanging);
Assert.Equal(1, countChanged);
Assert.Equal(1, collectionChanged);
Assert.Equal(new[] { "Abrash", "Brendan", "Nate" }, hashSet.OrderBy(i => i));
hashSet.SymmetricExceptWith(new string[0]);
Assert.Equal(1, countChanging);
Assert.Equal(1, countChanged);
Assert.Equal(1, collectionChanged);
Assert.Equal(new[] { "Abrash", "Brendan", "Nate" }, hashSet.OrderBy(i => i));
}
public void Can_remove_with_predicate()
{
var hashSet = new ObservableHashSet <string> {
"Brendan", "Carmack", "Nate", "Palmer"
};
var countChanging = 0;
var countChanged = 0;
var collectionChanged = 0;
var currentCount = 4;
var countChange = -2;
var removing = new[] { "Carmack", "Palmer" };
hashSet.PropertyChanging += (s, a) => AssertCountChanging(hashSet, s, a, currentCount, ref countChanging);
hashSet.PropertyChanged += (s, a) => AssertCountChanged(hashSet, s, a, ref currentCount, countChange, ref countChanged);
hashSet.CollectionChanged += (s, a) =>
{
Assert.Equal(NotifyCollectionChangedAction.Replace, a.Action);
Assert.Equal(removing, a.OldItems.OfType <string>().OrderBy(i => i));
Assert.Empty(a.NewItems);
collectionChanged++;
};
Assert.Equal(2, hashSet.RemoveWhere(i => i.Contains("m")));
Assert.Equal(1, countChanging);
Assert.Equal(1, countChanged);
Assert.Equal(1, collectionChanged);
Assert.Equal(new[] { "Brendan", "Nate" }, hashSet.OrderBy(i => i));
Assert.Equal(0, hashSet.RemoveWhere(i => i.Contains("m")));
Assert.Equal(1, countChanging);
Assert.Equal(1, countChanged);
Assert.Equal(1, collectionChanged);
Assert.Equal(new[] { "Brendan", "Nate" }, hashSet.OrderBy(i => i));
}
public void Can_union_with()
{
var hashSet = new ObservableHashSet <string> {
"Palmer", "Carmack"
};
var countChanging = 0;
var countChanged = 0;
var collectionChanged = 0;
var currentCount = 2;
var countChange = 2;
var adding = new[] { "Brendan", "Nate" };
hashSet.PropertyChanging += (s, a) => AssertCountChanging(hashSet, s, a, currentCount, ref countChanging);
hashSet.PropertyChanged += (s, a) => AssertCountChanged(hashSet, s, a, ref currentCount, countChange, ref countChanged);
hashSet.CollectionChanged += (s, a) =>
{
Assert.Equal(NotifyCollectionChangedAction.Replace, a.Action);
Assert.Empty(a.OldItems);
Assert.Equal(adding, a.NewItems.OfType <string>().OrderBy(i => i));
collectionChanged++;
};
hashSet.UnionWith(new[] { "Carmack", "Nate", "Brendan" });
Assert.Equal(1, countChanging);
Assert.Equal(1, countChanged);
Assert.Equal(1, collectionChanged);
Assert.Equal(new[] { "Brendan", "Carmack", "Nate", "Palmer" }, hashSet.OrderBy(i => i));
hashSet.UnionWith(new[] { "Brendan" });
Assert.Equal(1, countChanging);
Assert.Equal(1, countChanged);
Assert.Equal(1, collectionChanged);
Assert.Equal(new[] { "Brendan", "Carmack", "Nate", "Palmer" }, hashSet.OrderBy(i => i));
}
public MprFeatureGroup()
{
_mprFeatures = new ObservableHashSet <MprFeature>();
_mprFeatures.CollectionChanged += MprFeaturesChanged;
}
public void WhenRemove_ThenCountUpdated() {
// Arrange
var target = new ObservableHashSet<int>();
target.Add(1);
target.Add(2);
target.Add(3);
target.Add(4);
// Act
target.Remove(3);
var actual = target.Count;
// Assert
Assert.AreEqual(3, actual);
}
public ActionFinishedArgument(ObservableHashSet <FollowerUI> followed, ObservableHashSet <FollowerUI> unFollowed)
{
Followed = new ObservableHashSet <FollowerUI>(followed);
UnFollowed = new ObservableHashSet <FollowerUI>(unFollowed);
}
private void ResetCollectionChangedEvent(ObservableHashSet <Entity> oldCollection, ObservableHashSet <Entity> newCollection)
{
if (oldCollection != null)
{
oldCollection.CollectionChanged -= SelectedEntities_CollectionChanged;
}
if (newCollection != null)
{
newCollection.CollectionChanged += SelectedEntities_CollectionChanged;
}
}
public void LoadLevel(LevelSave levelSave)
{
Room room = OrbIt.game.room;
//room.worldWidth = levelSave.levelWidth;
//room.worldHeight = levelSave.levelHeight;
v = new Vector2(levelSave.levelWidth, levelSave.levelHeight);
room.resize(v, true);
room.waitTimeCounter = 0;
if (!levelSaves.ContainsKey(levelSave))
{
ObservableHashSet<Node> nodes = new ObservableHashSet<Node>();
for (int i = 0; i < levelSave.polygonVertices.Count; i++)
{
Node newNode = new Node(sidebar.ui.game.room, ShapeType.Polygon);
Polygon poly = (Polygon)newNode.body.shape;
//poly.SetCenterOfMass(vertices);
float[] list = levelSave.polygonVertices[i];
for (int j = 0; j < list.Length / 2; j++)
{
poly.vertices[j] = new Vector2(list[j * 2], list[(j * 2) + 1]);
}
poly.vertexCount = list.Length / 2;
newNode.body.pos = new Vector2(levelSave.polygonPositions[i][0], levelSave.polygonPositions[i][1]);
newNode.body.SetStatic();
newNode.body.orient = 0;
newNode.movement.mode = movemode.free;
newNode.body.restitution = 1f;
newNode.body.texture = textures.rock1;
newNode.meta.maxHealth.enabled = false;
poly.ComputeNormals();
poly.CalibrateTexture();
nodes.Add(newNode);
}
levelSaves[levelSave] = nodes;
}
ObservableHashSet<Node> incomingNodes = levelSaves[levelSave];
foreach (Node n in wallGroup.entities.ToList())
{
wallGroup.DiscludeEntity(n);
}
foreach (Node n in incomingNodes)
{
wallGroup.IncludeEntity(n);
}
}
public void Chain()
{
if (chainList.Count < 2) return;
for(int i = 0; i < chainList.Count; i++)
{
if (i == chainList.Count - 1) AffectionSets[chainList[i]] = new ObservableHashSet<Node>() { chainList[0] };
else AffectionSets[chainList[i]] = new ObservableHashSet<Node>() { chainList[i + 1] };
}
}
public override ProblemCollection Check(TypeNode type)
{
Debug.WriteLine("Checking type:" + type.FullName);
var initializer = type.Members.OfType<Method>().FirstOrDefault(x => x.FullName == type.FullName + ".InitializeComponent");
if (initializer == null)
return null;
Debug.WriteLine(initializer.FullName);
var constructorsWithNoInitCall = type.Members.OfType<Method>().Where(m => m.NodeType == NodeType.InstanceInitializer).ToList();
var visitedMethods = new HashSet<string>();
var foundMethods = new ObservableHashSet<Method>();
var whenMethodsFound = Observable.FromEvent<NotifyCollectionChangedEventArgs>(foundMethods, "CollectionChanged")
.Where(e => e.EventArgs.Action == NotifyCollectionChangedAction.Add
&& constructorsWithNoInitCall.Any());
whenMethodsFound.Subscribe(e => Parallel.ForEach(e.EventArgs.NewItems.OfType<Method>()
.Where(m => !visitedMethods.Any(v => v == m.FullName)),
i =>
{
lock (visitedMethods)
{
if (visitedMethods.Contains(i.FullName))
return;
visitedMethods.Add(i.FullName);
}
Debug.WriteLine("Visiting:" + i.FullName);
var callers = (CallGraph.CallersFor(i));
constructorsWithNoInitCall.RemoveAll(x => callers.Any(c => x.FullName == c.FullName));
if (constructorsWithNoInitCall.Any())
foreach (var item in callers.Where(c => visitedMethods.Any(v => v == c.FullName) == false))
{
foundMethods.Add(item);
}
}));
//e =>
//{
// Parallel.ForEach(e.EventArgs.NewItems.OfType<Method>()
// .Where(m => !visitedMethods.Any(v => v == m.FullName) ),
// i =>
// {
// lock (visitedMethods)
// {
// if (visitedMethods.Contains(i.FullName))
// return;
// visitedMethods.Add(i.FullName);
// }
// Debug.WriteLine("Visiting:" + i.FullName);
// var callers = (CallGraph.CallersFor(i));
// constructorsWithNoInitCall.RemoveAll(x => callers.Any(c => x.FullName == c.FullName));
// if (constructorsWithNoInitCall.Any())
// foreach (var item in callers.Where(c => visitedMethods.Any(v => v == c.FullName) == false))
// {
// foundMethods.Add(item);
// }
// });
//));
foundMethods.Add(initializer);
//whenMethodsFound.Run();
//_currentType=type;
ReportProblem(constructorsWithNoInitCall, type);
return Problems;
}
public override ProblemCollection Check(TypeNode type)
{
Debug.WriteLine("Checking type:" + type.FullName);
var initializer = type.Members.OfType <Method>().FirstOrDefault(x => x.FullName == type.FullName + ".InitializeComponent");
if (initializer == null)
{
return(null);
}
Debug.WriteLine(initializer.FullName);
var constructorsWithNoInitCall = type.Members.OfType <Method>().Where(m => m.NodeType == NodeType.InstanceInitializer).ToList();
var visitedMethods = new HashSet <string>();
var foundMethods = new ObservableHashSet <Method>();
var whenMethodsFound = Observable.FromEvent <NotifyCollectionChangedEventArgs>(foundMethods, "CollectionChanged")
.Where(e => e.EventArgs.Action == NotifyCollectionChangedAction.Add &&
constructorsWithNoInitCall.Any());
whenMethodsFound.Subscribe(e => Parallel.ForEach(e.EventArgs.NewItems.OfType <Method>()
.Where(m => !visitedMethods.Any(v => v == m.FullName)),
i =>
{
lock (visitedMethods)
{
if (visitedMethods.Contains(i.FullName))
{
return;
}
visitedMethods.Add(i.FullName);
}
Debug.WriteLine("Visiting:" + i.FullName);
var callers = (CallGraph.CallersFor(i));
constructorsWithNoInitCall.RemoveAll(x => callers.Any(c => x.FullName == c.FullName));
if (constructorsWithNoInitCall.Any())
{
foreach (var item in callers.Where(c => visitedMethods.Any(v => v == c.FullName) == false))
{
foundMethods.Add(item);
}
}
}));
//e =>
//{
// Parallel.ForEach(e.EventArgs.NewItems.OfType<Method>()
// .Where(m => !visitedMethods.Any(v => v == m.FullName) ),
// i =>
// {
// lock (visitedMethods)
// {
// if (visitedMethods.Contains(i.FullName))
// return;
// visitedMethods.Add(i.FullName);
// }
// Debug.WriteLine("Visiting:" + i.FullName);
// var callers = (CallGraph.CallersFor(i));
// constructorsWithNoInitCall.RemoveAll(x => callers.Any(c => x.FullName == c.FullName));
// if (constructorsWithNoInitCall.Any())
// foreach (var item in callers.Where(c => visitedMethods.Any(v => v == c.FullName) == false))
// {
// foundMethods.Add(item);
// }
// });
//));
foundMethods.Add(initializer);
//whenMethodsFound.Run();
//_currentType=type;
ReportProblem(constructorsWithNoInitCall, type);
return(Problems);
}
public Room(OrbIt game, int worldWidth, int worldHeight, bool Groups = true)
{
groups = new RoomGroups(this);
AllActiveLinks = new ObservableHashSet<Link>();
AllInactiveLinks = new ObservableHashSet<Link>();
this.worldWidth = worldWidth;
this.worldHeight = worldHeight;
scheduler = new Scheduler();
borderColor = Color.DarkGray;
// grid System
gridsystemAffect = new GridSystem(this, 40, new Vector2(0, worldHeight - OrbIt.ScreenHeight), worldWidth, OrbIt.ScreenHeight);
collisionManager = new CollisionManager(this);
//gridsystemAffect = new GridSystem(this, 40, new Vector2(0, worldHeight - OrbIt.Height), worldWidth, OrbIt.Height);
level = new Level(this, 40, 40, gridsystemAffect.cellWidth, gridsystemAffect.cellHeight);
roomRenderTarget = new RenderTarget2D(game.GraphicsDevice, OrbIt.ScreenWidth, OrbIt.ScreenHeight);
//gridsystemCollision = new GridSystem(this, gridsystemAffect.cellsX, new Vector2(0, worldHeight - OrbIt.Height), worldWidth, OrbIt.Height);
camera = new ThreadedCamera(this, 1f);
DrawLinks = true;
scheduler = new Scheduler();
players = new HashSet<Player>();
#region ///Default User props///
Dictionary<dynamic, dynamic> userPr = new Dictionary<dynamic, dynamic>() {
{ nodeE.position, new Vector2(0, 0) },
{ nodeE.texture, textures.blackorb },
};
#endregion
defaultNode = new Node(this, userPr);
defaultNode.name = "master";
//defaultNode.IsDefault = true;
foreach(Component c in defaultNode.comps.Values)
{
c.AfterCloning();
}
Node firstdefault = new Node(this, ShapeType.Circle);
//firstdefault.addComponent(comp.itempayload, true);
Node.cloneNode(defaultNode, firstdefault);
firstdefault.name = "[G0]0";
//firstdefault.IsDefault = true;
masterGroup = new Group(this, defaultNode, null, defaultNode.name, false);
if (Groups)
{
new Group(this, defaultNode, masterGroup, "General Groups", false);
new Group(this, defaultNode, masterGroup, "Preset Groups", false);
new Group(this, defaultNode.CreateClone(this), masterGroup, "Player Group", true);
new Group(this, defaultNode, masterGroup, "Item Group", false);
new Group(this, defaultNode, masterGroup, "Link Groups", false);
new Group(this, defaultNode.CreateClone(this), masterGroup, "Bullet Group", true);
new Group(this, defaultNode, masterGroup, "Wall Group", true);
new Group(this, firstdefault, groups.general, "Group1");
}
Dictionary<dynamic, dynamic> userPropsTarget = new Dictionary<dynamic, dynamic>() {
{ typeof(ColorChanger), true },
{ nodeE.texture, textures.ring }
};
targetNodeGraphic = new Node(this,userPropsTarget);
targetNodeGraphic.name = "TargetNodeGraphic";
//MakeWalls(WallWidth);
MakePresetGroups();
MakeItemGroups();
}
public void WhenSymmetricExceptWithAndOtherEquals_ThenRaisesCollectionChanged() {
// Arrange
var target = new ObservableHashSet<int>();
target.Add(1);
target.Add(2);
target.Add(3);
target.Add(4);
var other = new int[] { 1, 2, 3, 4 };
bool wasRemoveEventRaised = false;
target.CollectionChanged += (s, e) => {
if (e.Action == NotifyCollectionChangedAction.Remove &&
e.OldItems.Count == 4 &&
e.OldItems.Contains(1) &&
e.OldItems.Contains(2) &&
e.OldItems.Contains(3) &&
e.OldItems.Contains(4)) {
wasRemoveEventRaised = true;
}
};
bool wasAddEventRaised = false;
target.CollectionChanged += (s, e) => {
if (e.Action == NotifyCollectionChangedAction.Add) {
wasAddEventRaised = true;
}
};
// Act
target.SymmetricExceptWith(other);
// Assert
Assert.IsTrue(wasRemoveEventRaised);
Assert.IsFalse(wasAddEventRaised);
}
public Room(int worldWidth, int worldHeight, bool groups = true)
{
Transform = new Transform();
Transform.rotation = Quaternion.RotationAxis(Vector3.Up, (float)Math.PI);
Groups = new RoomGroups(this);
AllActiveLinks = new ObservableHashSet <Link>();
AllInactiveLinks = new ObservableHashSet <Link>();
WorldWidth = worldWidth;
WorldHeight = worldHeight;
Scheduler = new Scheduler();
BorderColor = Color.DarkGray;
// grid System
GridsystemAffect = new GridSystem(this, 40, new Vector2R(0, 0), worldWidth, OrbIt.ScreenHeight);
CollisionManager = new CollisionManager(this);
Level = new Level(this, 40, 40, GridsystemAffect.cellWidth, GridsystemAffect.cellHeight);
Camera = new MeshCamera(this, 1f, Vector2R.Zero);
DrawLinks = true;
Scheduler = new Scheduler();
Dictionary <dynamic, dynamic> userPr = new Dictionary <dynamic, dynamic>()
{
{ nodeE.position, new Vector2R(0, 0) },
{ nodeE.texture, Textures.Blackorb },
};
DefaultNode = new Node(this, userPr)
{
name = "master"
};
//defaultNode.IsDefault = true;
foreach (Component c in DefaultNode.comps.Values)
{
c.AfterCloning();
}
Node firstdefault = new Node(this, ShapeType.Circle);
//firstdefault.addComponent(comp.itempayload, true);
Node.cloneNode(DefaultNode, firstdefault);
firstdefault.name = "[G0]0";
//firstdefault.IsDefault = true;
MasterGroup = new Group(this, DefaultNode, DefaultNode.name, false);
if (groups)
{
MasterGroup.AddGroup(new Group(this, DefaultNode, "General Groups", false));
MasterGroup.AddGroup(new Group(this, DefaultNode, "Preset Groups", false));
MasterGroup.AddGroup(new Group(this, DefaultNode.CreateClone(this), "Player Group"));
MasterGroup.AddGroup(new Group(this, DefaultNode, "Item Group", false));
MasterGroup.AddGroup(new Group(this, DefaultNode, "Link Groups", false));
MasterGroup.AddGroup(new Group(this, DefaultNode.CreateClone(this), "Bullet Group"));
MasterGroup.AddGroup(new Group(this, DefaultNode, "Wall Group"));
Groups.General.AddGroup(new Group(this, firstdefault, "Group1"));
}
Dictionary <dynamic, dynamic> userPropsTarget = new Dictionary <dynamic, dynamic>()
{
{ typeof(ColorChanger), true },
{ nodeE.texture, Textures.Ring }
};
TargetNodeGraphic = new Node(this, userPropsTarget)
{
name = "TargetNodeGraphic"
};
if (DebugFlags.addRoomWalls)
{
MakeWalls(10);
}
MakePresetGroups();
MakeItemGroups();
}
public void WhenUnionWithAndOtherEqual_ThenDoesNotRaiseCountPropertyChanged() {
// Arrange
var target = new ObservableHashSet<int>();
target.Add(1);
target.Add(2);
target.Add(3);
target.Add(4);
var other = new int[] { 1, 2, 3, 4 };
bool wasEventRaised = false;
target.PropertyChanged += (s, e) => {
if (e.PropertyName == ObservableHashSet<int>.PropertyNames.Count) {
wasEventRaised = true;
}
};
// Act
target.UnionWith(other);
// Assert
Assert.IsFalse(wasEventRaised);
}
public void WhenUnionWithAndOtherEqual_ThenDoesNotRaiseCollectionChanged() {
// Arrange
var target = new ObservableHashSet<int>();
target.Add(1);
target.Add(2);
target.Add(3);
target.Add(4);
var other = new int[] { 1, 2, 3, 4 };
bool wasEventRaised = false;
target.CollectionChanged += (s, e) => {
if (e.Action == NotifyCollectionChangedAction.Add) {
wasEventRaised = true;
}
};
// Act
target.UnionWith(other);
// Assert
Assert.IsFalse(wasEventRaised);
}
public void WhenUnionWith_ThenRaisesCollectionChanged() {
// Arrange
var target = new ObservableHashSet<int>();
target.Add(1);
target.Add(2);
target.Add(3);
target.Add(4);
var other = new int[] { 1, 4, 5, 6 };
bool wasEventRaised = false;
target.CollectionChanged += (s, e) => {
if (e.Action == NotifyCollectionChangedAction.Add &&
e.NewItems.Count == 2 &&
e.NewItems.Contains(5) &&
e.NewItems.Contains(6)) {
wasEventRaised = true;
}
};
// Act
target.UnionWith(other);
// Assert
Assert.IsTrue(wasEventRaised);
}
public TradingDataContext()
{
//this.Strategies = new ObservableHashSet<Strategy>(new IdentifiedComparer());
//this.Signals = new ObservableHashSet<Signal>(new IdentifiedComparer());
//this.Orders = new ObservableHashSet<Order>(new IdentifiedComparer());
//this.Trades = new ObservableHashSet<Trade>(new IdentifiedComparer());
//this.CancellationRequests = new ObservableHashSet<OrderCancellationRequest>(new IdentifiedComparer());
//this.CancellationConfirmations = new ObservableHashSet<OrderCancellationConfirmation>(new IdentifiedComparer());
//this.CancellationFaults = new ObservableHashSet<OrderCancellationFailedNotification>(new IdentifiedComparer());
//this.OrderRejections = new ObservableHashSet<OrderRejection>(new IdentifiedComparer());
//this.Positions = new ObservableHashSet<Position>(new PositionEqualityComparer());
//this.OrderSettings = new ObservableHashSet<OrderSettings>(new IdentifiedComparer());
//this.StopLossOrderSettings = new ObservableHashSet<StopLossOrderSettings>(new IdentifiedComparer());
//this.TakeProfitOrderSettings = new ObservableHashSet<TakeProfitOrderSettings>(new IdentifiedComparer());
//this.BarSettings = new ObservableHashSet<BarSettings>(new IdentifiedComparer());
//this.StopLossSettings = new ObservableHashSet<StopPointsSettings>(new IdentifiedComparer());
//this.TakeProfitSettings = new ObservableHashSet<ProfitPointsSettings>(new IdentifiedComparer());
//this.OrderDeliveryConfirmations = new ObservableHashSet<OrderDeliveryConfirmation>(new OrderDeliveryConfirmationComparer());
//this.SMASettings = new ObservableHashSet<SMASettings>(new IdentifiedComparer());
//this.OpenOrders = new ObservableHashSet<OpenOrder>(new IdentifiedComparer());
//this.CloseOrders = new ObservableHashSet<CloseOrder>(new IdentifiedComparer());
//this.PositionsSettings = new ObservableHashSet<PositionSettings>(new IdentifiedComparer());
//this.Trends = new ObservableHashSet<Trend>(new TrendEqualityComparer());
//this.Symbols = new HashSetOfNamedMutable<Symbol>();
//this.Ticks = new ObservableCollection<Tick>();
//this.Bars = new ObservableCollection<Bar>();
//this.BidAsks = new ObservableCollection<BidAsk>();
//this.OrderMoveRequests = new ObservableCollection<OrderMoveRequest>();
//this.StrategyVolumeChangeSteps = new ObservableHashSet<StrategyVolumeChangeStep>(new IdentifiedComparer());
//this.SpreadValues = new ObservableCollection<SpreadValue>();
//this.ArbitrageSettings = new ObservableHashSet<ArbitrageSettings>(new IdentifiedComparer());
//this.MoveOrders = new ObservableHashSet<MoveOrder>();
this.Strategies = new ObservableHashSet <StrategyHeader>(new IdentifiedComparer());
this.Signals = new ObservableHashSet <Signal>(new IdentifiedComparer());
this.Orders = new ObservableHashSet <Order>(new IdentifiedComparer());
this.Trades = new ObservableHashSet <Trade>(new IdentifiedComparer());
this.Symbols = new HashSetOfNamedMutable <Symbol>();
this.Ticks = new ObservableCollection <Tick>();
this.Bars = new ObservableCollection <Bar>();
this.BidAsks = new ObservableCollection <BidAsk>();
this.Positions = new ObservableHashSet <Position>(new PositionEqualityComparer());
this.PositionsSettings = new ObservableHashSet <PositionSettings>(new IdentifiedComparer());
this.CancellationRequests = new ObservableHashSet <OrderCancellationRequest>(new IdentifiedComparer());
this.CancellationConfirmations = new ObservableHashSet <OrderCancellationConfirmation>(new IdentifiedComparer());
this.CancellationFaults = new ObservableHashSet <OrderCancellationFailedNotification>(new IdentifiedComparer());
this.OrderRejections = new ObservableHashSet <OrderRejection>(new IdentifiedComparer());
this.MoveOrders = new ObservableHashSet <MoveOrder>();
this.OrderMoveRequests = new ObservableCollection <OrderMoveRequest>();
this.OrderDeliveryConfirmations = new ObservableHashSet <OrderDeliveryConfirmation>(new OrderDeliveryConfirmationComparer());
this.OpenOrders = new ObservableHashSet <OpenOrder>(new IdentifiedComparer());
this.CloseOrders = new ObservableHashSet <CloseOrder>(new IdentifiedComparer());
this.OrderSettings = new ObservableHashSet <OrderSettings>(new IdentifiedComparer());
this.StopLossOrderSettings = new ObservableHashSet <StopLossOrderSettings>(new IdentifiedComparer());
this.TakeProfitOrderSettings = new ObservableHashSet <TakeProfitOrderSettings>(new IdentifiedComparer());
this.BarSettings = new ObservableHashSet <BarSettings>(new IdentifiedComparer());
this.StopLossSettings = new ObservableHashSet <StopPointsSettings>(new IdentifiedComparer());
this.TakeProfitSettings = new ObservableHashSet <ProfitPointsSettings>(new IdentifiedComparer());
this.StrategyVolumeChangeSteps = new ObservableHashSet <StrategyVolumeChangeStep>(new IdentifiedComparer());
this.SpreadValues = new ObservableCollection <SpreadValue>();
this.ArbitrageSettings = new ObservableHashSet <ArbitrageSettings>(new IdentifiedComparer());
this.Trends = new ObservableHashSet <Trend>(new TrendEqualityComparer());
this.SMASettings = new ObservableHashSet <SMASettings>(new IdentifiedComparer());
// добавить
}
//used for NearestN or FurthestN
public void NearestN()
{
if (link.sources != null)
{
//not effecient if NearestNValue == 1 because it sorts the entire list of distances
HashSet<Node> AlreadyInhabited = new HashSet<Node>();
link.sources.ToList().ForEach(delegate(Node source)
{
AffectionSets[source] = new ObservableHashSet<Node>();
ObservableHashSet<Node> set = AffectionSets[source];
List<Tuple<float, Node>> DistancesList = new List<Tuple<float, Node>>();
Comparison<Tuple<float, Node>> comparer;
if (FormationType == formationtype.NearestN)
{
comparer = delegate(Tuple<float, Node> first, Tuple<float, Node> second)
{
if (first.Item1 < second.Item1) return -1;
else if (first.Item1 > second.Item1) return 1;
return 0;
};
}
else if (FormationType == formationtype.FurthestN)
{
comparer = delegate(Tuple<float, Node> first, Tuple<float, Node> second)
{
if (first.Item1 > second.Item1) return -1;
else if (first.Item1 < second.Item1) return 1;
return 0;
};
}
else return;
link.targets.ToList().ForEach(delegate(Node target)
{
if (source == target) return;
DistancesList.Add(new Tuple<float, Node>(Vector2.DistanceSquared(source.body.pos, target.body.pos), target));
});
DistancesList.Sort(comparer);
int min = Math.Min(NearestNValue, DistancesList.Count);
/*
for (int i = 0; i < min; i++)
{
set.Add(DistancesList.ElementAt(i).Item2);
}
*/
int count = 0;
int it = 0;
while (count < min)
{
if (it >= DistancesList.Count) break;
Node nn = DistancesList.ElementAt(it).Item2;
if (Uninhabited)
{
if (AlreadyInhabited.Contains(nn))
{
it++;
continue;
}
else
{
AlreadyInhabited.Add(nn);
}
}
set.Add(nn);
count++;
it++;
}
});
}
}
public static void LoadLevelSpider(LevelSave levelSave)
{
Room room = OrbIt.game.room;
//room.worldWidth = levelSave.levelWidth;
//room.worldHeight = levelSave.levelHeight;
Vector2 v = new Vector2(levelSave.levelWidth, levelSave.levelHeight);
room.resize(v, true);
room.waitTimeCounter = 0;
ObservableHashSet<Node> nodes = new ObservableHashSet<Node>();
for (int i = 0; i < levelSave.polygonVertices.Count; i++)
{
Node newNode = new Node(OrbIt.ui.game.room, ShapeType.Polygon);
Polygon poly = (Polygon)newNode.body.shape;
//poly.SetCenterOfMass(vertices);
float[] list = levelSave.polygonVertices[i];
for (int j = 0; j < list.Length / 2; j++)
{
poly.vertices[j] = new Vector2(list[j * 2], list[(j * 2) + 1]);
}
poly.vertexCount = list.Length / 2;
newNode.body.pos = new Vector2(levelSave.polygonPositions[i][0], levelSave.polygonPositions[i][1]);
newNode.body.SetStatic();
newNode.body.orient = 0;
newNode.movement.mode = movemode.free;
newNode.body.restitution = 1f;
newNode.body.texture = textures.rock1;
newNode.meta.maxHealth.enabled = false;
poly.ComputeNormals();
poly.CalibrateTexture();
nodes.Add(newNode);
}
foreach (var dd in levelSave.Diodes)
{
var dict = new Dictionary<dynamic, dynamic>() { { typeof(Diode), true }, { nodeE.texture, textures.gradient1 } };
Node lastSpawnedDiode = Node.ContructLineWall(room, new Vector2(dd.start[0], dd.start[1]), new Vector2(dd.end[0], dd.end[1]), DiodeSpawner.diodeThickness, dict, false);
lastSpawnedDiode.SetColor(new Color(255, 255, 255, 255));
lastSpawnedDiode.Comp<Diode>().start = new Vector2(dd.start[0], dd.start[1]);
lastSpawnedDiode.Comp<Diode>().end = new Vector2(dd.end[0], dd.end[1]);
lastSpawnedDiode.Comp<Diode>().semaphore = dd.isSemaphore;
lastSpawnedDiode.Comp<Diode>().maxTickets = dd.tickets;
lastSpawnedDiode.body.orient = dd.orientation;
room.masterGroup.IncludeEntity(lastSpawnedDiode);
lastSpawnedDiode.OnSpawn();
}
ObservableHashSet<Node> incomingNodes = nodes;
foreach (Node n in room.groups.walls.entities.ToList())
{
room.groups.walls.DiscludeEntity(n);
}
foreach (Node n in incomingNodes)
{
room.groups.walls.IncludeEntity(n);
}
foreach (Node n in room.groups.walls.entities)
{
n.collision.UpdateCollisionSet();
}
finalizeLevelLoad(v);
}
public override void PlayerControl(Input input)
{
Vector2 newstickpos = input.GetRightStick(shovelReach, true);//input.GetRightStick();
Vector2 pos = newstickpos * shovelReach;
Vector2 worldStickPos = parent.body.pos + pos;
Vector2 diff = worldStickPos - shovelNode.body.pos;
//float angle = Utils.VectorToAngle(shovelNode.body.pos - parent.body.pos) + VMath.PIbyTwo % VMath.twoPI;
Vector2 shovelDir = shovelNode.body.pos - parent.body.pos;
shovelDir = new Vector2(shovelDir.Y, -shovelDir.X);
shovelNode.body.SetOrientV2(shovelDir);
if (modeShovelPosition == ModeShovelPosition.AbsoluteStickPos)
{
shovelNode.body.pos = worldStickPos;
}
else if (modeShovelPosition == ModeShovelPosition.PhysicsBased)
{
float len = diff.Length();
if (len < 1)
{
shovelNode.body.velocity = Vector2.Zero;
}
else
{
float velLen = shovelNode.body.velocity.Length();
Vector2 diffcopy = diff;
VMath.NormalizeSafe(ref diffcopy);
Vector2 normalizedVel = shovelNode.body.velocity;
VMath.NormalizeSafe(ref normalizedVel);
float result = 0;
Vector2.Dot(ref diffcopy, ref normalizedVel, out result);
diffcopy *= result;
Vector2 force = (diff / physicsDivisor);
if (shovelling && compoundedMass >= 1) force /= compoundedMass * 1;
shovelNode.body.velocity = diffcopy + force;
//shovelNode.body.ApplyForce(force);
}
}
if (shovelling)
{
//if (fc.newGamePadState.Triggers.Right < deadzone && fc.oldGamePadState.Triggers.Right > deadzone)
if (input.BtnReleased(InputButtons.RightTrigger_Mouse1))
{
shovelling = false;
foreach(Node n in shovelLink.targets.ToList())
{
if (physicsThrow)
{
n.body.velocity = n.body.effvelocity;
}
else
{
Vector2 stickdirection = newstickpos;
VMath.NormalizeSafe(ref stickdirection);
n.body.velocity = stickdirection * throwSpeed;
}
n.collision.active = true;
shovelLink.targets.Remove(n);
n.body.ClearExclusionChecks();
n.body.color = n.body.permaColor;
}
shovelLink.formation.UpdateFormation();
shovelLink.active = false;
shovelNode.room.AllActiveLinks.Remove(shovelLink);
compoundedMass = 0f;
}
}
else
{
if (input.BtnClicked(InputButtons.RightTrigger_Mouse1))
{
shovelling = true;
ObservableHashSet<Node> capturedNodes = new ObservableHashSet<Node>();
int count = 0;
Action<Collider, Collider> del = delegate(Collider c1, Collider c2){
if (count >= maxShovelCapacity) return;
if (c2.parent.dataStore.ContainsKey("shovelnodeparent"))return;
if (c2.parent.HasComp<Diode>()) return;
if (modePlayers != ModePlayers.GrabBoth && c2.parent.IsPlayer)
{
if (modePlayers == ModePlayers.GrabNone) return;
if (modePlayers == ModePlayers.GrabSelf && c2.parent != parent) return;
if (modePlayers == ModePlayers.GrabOtherPlayers && c2.parent == parent) return;
}
float dist = Vector2.Distance(c1.pos, c2.pos);
if (dist <= scoopReach)
{
count++;
capturedNodes.Add(c2.parent);
c2.parent.body.color = parent.body.color;
}
};
shovelNode.room.gridsystemAffect.retrieveOffsetArraysAffect(shovelNode.body, del, scoopReach * 2);
shovelLink.targets = capturedNodes;
shovelLink.formation.UpdateFormation();
shovelLink.active = true;
shovelNode.room.AllActiveLinks.Add(shovelLink);
compoundedMass = 0f;
foreach(Node n in capturedNodes)
{
n.collision.active = false;
compoundedMass += n.body.mass;
}
}
}
}
public GeneratorService()
{
Settings = new GenerateSettings();
Entries = new ObservableHashSet <string>(StringComparer.OrdinalIgnoreCase);
}
/// <summary>
/// Initialize the window and load the selected shader.
/// </summary>
/// <param name="sender">Object sending this event.</param>
/// <param name="e">Argument for this event.</param>
private void Window_Loaded(object sender, RoutedEventArgs e)
{
ShaderList = new ObservableHashSet<Shader>();
_filteredList = new CollectionViewSource();
_filteredList.Source = ShaderList;
_filteredList.Filter += FilteredList_Filter;
listBox.ItemsSource = _filteredList.View;
RefreshList();
// Select the current shader
RegistryKey folder = Registry.CurrentUser.CreateSubKey(@"Software\GLow Screensaver\");
if (folder.GetValue("ShaderId") != null)
{
int shaderId = (int)folder.GetValue("ShaderId");
foreach (Shader shader in ShaderList)
{
if (shader.Id == shaderId)
{
listBox.SelectedItem = shader;
listBox.ScrollIntoView(listBox.SelectedItem);
break;
}
}
}
else if (ShaderList.Count > 0) listBox.SelectedIndex = 0;
}
public Mode()
{
Modes = new ObservableHashSet<char>();
ModesString = new ObservableProperty<String>(String.Empty);
}
public ScraperController()
{
this.Tasks = new ObservableHashSet <Task>(XmlTaskDatabase.Instance.Tasks);
this.OnPropertyChanged("Tasks");
}
public void WhenRemove_ThenRaisesCollectionChanged() {
// Arrange
var target = new ObservableHashSet<int>();
target.Add(1);
target.Add(2);
target.Add(3);
target.Add(4);
bool wasEventRaised = false;
target.CollectionChanged += (s, e) => {
if (e.Action == NotifyCollectionChangedAction.Remove && e.OldItems.Contains(3)) {
wasEventRaised = true;
}
};
// Act
target.Remove(3);
// Assert
Assert.IsTrue(wasEventRaised);
}
public void OldTests()
{
//////////////////////////////////////////////////////////////////////////////////////
List<int> ints = new List<int> { 1, 2, 3 };
ints.ForEach(delegate(int i) { if (i == 2) ints.Remove(i); }); //COOL: NO ENUMERATION WAS MODIFIED ERROR
ints.ForEach(delegate(int i) { Console.WriteLine(i); });
MethodInfo testmethod = room.GetType().GetMethod("test");
Action<Room, int, float, string> del = (Action<Room, int, float, string>)Delegate.CreateDelegate(typeof(Action<Room, int, float, string>), testmethod);
del(room, 1, 0.3f, "Action worked.");
Action<int, float, string> del2 = (Action<int, float, string>)Delegate.CreateDelegate(typeof(Action<int, float, string>), room, testmethod);
//target is bound to 'room' in this example due to the overload of CreateDelegate used.
del2(2, 3.3f, "Action worked again.");
PropertyInfo pinfo = typeof(Component).GetProperty("active");
MethodInfo minfo = pinfo.GetGetMethod();
Console.WriteLine("{0}", minfo.ReturnType);
Movement tester = new Movement();
tester.active = true;
bool ret = (bool)minfo.Invoke(tester, new object[] { }); //VERY expensive (slow)
Console.WriteLine("{0}", ret);
Func<Component, bool> delGet = (Func<Component, bool>)Delegate.CreateDelegate(typeof(Func<Component, bool>), minfo);
Console.WriteLine("{0}", delGet(tester)); //very fast, and no cast or creation of empty args array required
minfo = pinfo.GetSetMethod();
//Console.WriteLine("{0} {1}", minfo.ReturnType, minfo.GetParameters()[0].ParameterType);
Action<Component, bool> delSet = (Action<Component, bool>)Delegate.CreateDelegate(typeof(Action<Component, bool>), minfo);
delSet(tester, false);
Console.WriteLine("Here we go: {0}", delGet(tester));
delSet(tester, true);
/////////////////////////////////////////////////////////////////////////////////////////
/*
//gets all types that are a subclass of Component
List<Type> types = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(assembly => assembly.GetTypes())
.Where(type => type.IsSubclassOf(typeof(Component))).ToList();
foreach (Type t in types) Console.WriteLine(t);
*/
//room.defaultNode.Update(new GameTime()); //for testing
//MODIFIER ADDITION
/*
room.defaultNode.addComponent(comp.modifier, true); //room.defaultNode.comps[comp.modifier].active = false;
ModifierInfo modinfo = new ModifierInfo();
modinfo.AddFPInfoFromString("o1", "scale", room.defaultNode);
modinfo.AddFPInfoFromString("m1", "position", room.defaultNode);
modinfo.AddFPInfoFromString("v1", "position", room.defaultNode);
modinfo.args.Add("mod", 4.0f);
modinfo.args.Add("times", 3.0f);
modinfo.args.Add("test", 3.0f);
//modinfo.delegateName = "Mod";
//modinfo.delegateName = "Triangle";
//modinfo.delegateName = "VelocityToOutput";
//modinfo.delegateName = "VectorSine";
modinfo.delegateName = "VectorSineComposite";
room.defaultNode.comps[comp.modifier].modifierInfos["sinecomposite"] = modinfo;
*/
ObservableHashSet<int> obints = new ObservableHashSet<int>();
obints.CollectionChanged += (s, e) =>
{
if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add)
{
foreach (int i in e.NewItems)
{
Console.WriteLine("Added:" + i);
}
}
};
obints.Add(6);
}
public void WhenSymmetricExceptWithAndOtherEmpty_ThenDoesNotRaiseCollectionChanged() {
// Arrange
var target = new ObservableHashSet<int>();
target.Add(1);
target.Add(2);
target.Add(3);
target.Add(4);
var other = new int[] { };
bool wasRemoveEventRaised = false;
target.CollectionChanged += (s, e) => {
if (e.Action == NotifyCollectionChangedAction.Remove) {
wasRemoveEventRaised = true;
}
};
bool wasAddEventRaised = false;
target.CollectionChanged += (s, e) => {
if (e.Action == NotifyCollectionChangedAction.Add) {
wasAddEventRaised = true;
}
};
// Act
target.SymmetricExceptWith(other);
// Assert
Assert.IsFalse(wasRemoveEventRaised);
Assert.IsFalse(wasAddEventRaised);
}
public void WhenSymmetricExceptWith_ThenRaisesCountPropertyChanged() {
// Arrange
var target = new ObservableHashSet<int>();
target.Add(1);
target.Add(2);
target.Add(3);
target.Add(4);
var other = new int[] { 1, 4, 5, 6 };
bool wasEventRaised = false;
target.PropertyChanged += (s, e) => {
if (e.PropertyName == ObservableHashSet<int>.PropertyNames.Count) {
wasEventRaised = true;
}
};
// Act
target.SymmetricExceptWith(other);
// Assert
Assert.IsTrue(wasEventRaised);
}
public MprFeatureGroup()
{
_mprFeatures = new ObservableHashSet<MprFeature>();
_mprFeatures.CollectionChanged += MprFeaturesChanged;
}
