public async Task UpdatesExistingStartMessageFromContext(ComponentStatus changeStatus, ComponentStatus existingStatus)
{
var changedChild = new TestComponent("child");
var existingChild = new TestComponent("existing");
var root = new TreeComponent("hi", "", new[] { changedChild, existingChild });
var affectedComponent = root.GetByNames <IComponent>(root.Name, changedChild.Name);
var change = new MessageChangeEvent(
DefaultTimestamp,
affectedComponent.Path,
changeStatus,
MessageType.Start);
var existingAffectedComponent = root.GetByNames <IComponent>(root.Name, existingChild.Name);
var context = new ExistingStartMessageContext(
new DateTime(2018, 10, 9),
existingAffectedComponent,
existingStatus);
var result = await Processor.ProcessAsync(change, EventEntity, root, context);
Assert.Equal(context.Timestamp, result.Timestamp);
Assert.Equal(root, result.AffectedComponent);
Assert.Equal(root.Status, result.AffectedComponentStatus);
Factory
.Verify(
x => x.UpdateMessageAsync(
EventEntity,
context.Timestamp,
MessageType.Start,
root),
Times.Once());
}
public async Task ThrowsWhenUpdatingStartMessageFromContextWithoutLeastCommonAncestor(ComponentStatus changeStatus, ComponentStatus existingStatus)
{
var child = new TestComponent("child");
var root = new TreeComponent("hi", "", new[] { child });
var affectedComponent = root.GetByNames <IComponent>(root.Name, child.Name);
var change = new MessageChangeEvent(
DefaultTimestamp,
affectedComponent.Path,
changeStatus,
MessageType.Start);
var context = new ExistingStartMessageContext(
new DateTime(2018, 10, 9),
new TestComponent("no common ancestor"),
existingStatus);
await Assert.ThrowsAsync <ArgumentException>(() => Processor.ProcessAsync(change, EventEntity, root, context));
Factory
.Verify(
x => x.UpdateMessageAsync(
It.IsAny <EventEntity>(),
It.IsAny <DateTime>(),
It.IsAny <MessageType>(),
It.IsAny <IComponent>()),
Times.Never());
}
private void FeedCategoryTree_SelectItem(TreeComponent item)
{
if (item == null)
{
return;
}
if (item.Item is Channel)
{
var channel = item.Item as Channel;
var feedItems = _feedService.GetFeedItems(channel.ChannelId);
SetFeedItems(feedItems, channel.Title);
}
if (item.Item is Category)
{
}
if (item.TreeComponentType == TreeComponentType.Feed)
{
var feedItems = _feedService.GetFeedItems();
SetFeedItems(feedItems);
}
if (item.TreeComponentType == TreeComponentType.Subscriptions)
{
}
}
public async Task CreatesStartMessageFromNullContext(ComponentStatus status)
{
var child = new TestComponent("child");
var root = new TreeComponent("hi", "", new[] { child });
var affectedComponent = root.GetByNames <IComponent>(root.Name, child.Name);
var change = new MessageChangeEvent(
DefaultTimestamp,
affectedComponent.Path,
status,
MessageType.Start);
var result = await Processor.ProcessAsync(change, EventEntity, root, null);
Assert.Equal(change.Timestamp, result.Timestamp);
Assert.Equal(affectedComponent, result.AffectedComponent);
Assert.Equal(affectedComponent.Status, result.AffectedComponentStatus);
Factory
.Verify(
x => x.CreateMessageAsync(
EventEntity,
DefaultTimestamp,
MessageType.Start,
affectedComponent),
Times.Once());
}
public override bool checkProceduralPrecondition (GameObject agent)
{
// find the nearest tree that we can chop
TreeComponent[] trees = (TreeComponent[]) UnityEngine.GameObject.FindObjectsOfType ( typeof(TreeComponent) );
TreeComponent closest = null;
float closestDist = 0;
foreach (TreeComponent tree in trees) {
if (closest == null) {
// first one, so choose it for now
closest = tree;
closestDist = (tree.gameObject.transform.position - agent.transform.position).magnitude;
} else {
// is this one closer than the last?
float dist = (tree.gameObject.transform.position - agent.transform.position).magnitude;
if (dist < closestDist) {
// we found a closer one, use it
closest = tree;
closestDist = dist;
}
}
}
if (closest == null)
return false;
targetTree = closest;
target = targetTree.gameObject;
return closest != null;
}
private void InitializeFeed()
{
_feedComponent = new TreeComponent()
{
Name = "Feed",
PopupType = PopupType.FeedPopup,
TreeComponentType = TreeComponentType.Feed,
NewFeedItemsCountManual = 0
};
var categories = _categoryService.GetCategories();
_subscriptionsComponent = new TreeComponent(
ConvertCategoriesToTreeComponents(categories))
{
Name = "Subscriptions",
PopupType = PopupType.SubscriptionsPopup,
TreeComponentType = TreeComponentType.Subscriptions
};
TreeComponents = new ObservableCollection <TreeComponent>()
{
_feedComponent,
_subscriptionsComponent
};
FeedListItems = new ObservableCollection <FeedListItem>();
}
public void update(GameTime gameTime)
{
if (!_paused || _singleStep)
{
string levelUid = LevelSystem.currentLevelUid;
LevelSystem levelSystem = _systemManager.getSystem(SystemType.Level) as LevelSystem;
if (levelSystem.finalized)
{
List <int> treeEntities = _entityManager.getEntitiesPosessing(levelUid, ComponentType.Tree);
// Update treeAABB
Vector2 screenCenter = _renderSystem.screenCenter;
float halfWidth = ((float)_renderSystem.screenWidth / _renderSystem.scale) / 2f;
float halfHeight = ((float)_renderSystem.screenHeight / _renderSystem.scale) / 2f;
treeAABB.LowerBound.X = screenCenter.X - halfWidth;
treeAABB.UpperBound.X = screenCenter.X + halfWidth;
treeAABB.LowerBound.Y = screenCenter.Y - halfHeight;
treeAABB.UpperBound.Y = screenCenter.Y + halfHeight;
prepareCollisions();
for (int i = 0; i < treeEntities.Count; i++)
{
TreeComponent treeComponent = (TreeComponent)_entityManager.getComponent(levelUid, treeEntities[i], ComponentType.Tree);
treeComponent.tree.update();
}
}
}
_singleStep = false;
}
public override bool checkProceduralPrecondition(GameObject agent)
{
// find the nearest tree that we can chop
if (trees == null)
{
trees = FindObjectsOfType(typeof(TreeComponent)) as TreeComponent[];
}
if (sortedTrees == null)
{
sortedTrees = trees.OrderBy(t => Vector3.Distance(transform.position, t.transform.position));
}
if (closest == null)
{
foreach (TreeComponent tree in sortedTrees)
{
if (tree.treeResource > 0 && tree.engaged != true)
{
closest = tree;
break;
}
}
}
if (closest != null)
{
target = closest.gameObject;
}
return(closest != null);
}
/// <summary>
/// Set all specific values.
/// </summary>
/// <param name="treeComponent"></param>
public virtual void UpdateValues(TreeComponent treeComponent)
{
this.id = treeComponent.ID;
this.key = treeComponent.Key;
this.componentName = treeComponent.Name;
this.qualifier = treeComponent.Qualifier;
this.metrics = treeComponent.Metrics;
}
/// <summary>
/// Set the specific values.
/// </summary>
/// <param name="treeComponent"></param>
public override void UpdateValues(TreeComponent treeComponent)
{
base.UpdateValues(treeComponent);
foreach (TreeComponent component in ((DirComponent)treeComponent).components)
{
childString += "\n <b>" + component.Name + "</b>";
}
}
private float FindSpecificMetricValue(Metric metric, TreeComponent documentComponent)
{
foreach (TreeMetric m in documentComponent.Metrics)
{
if (m.Key.Equals(metric.key))
{
return((float)m.Value);
}
}
return((float)metric.defaultValue);
}
private void RemoveSubcomponentWithItem(TreeComponent treeComponent, object itemToRemove)
{
foreach (var subComponent in treeComponent.SubComponents)
{
if (subComponent.Item == itemToRemove)
{
treeComponent.SubComponents.Remove(subComponent);
return;
}
RemoveSubcomponentWithItem(subComponent, itemToRemove);
}
}
/// <summary>
///
/// </summary>
/// <param name="args"></param>
/// <returns></returns>
private async Task OnClick(MouseEventArgs args)
{
SelfNode.SetSelected(!SelfNode.Selected);
if (TreeComponent.OnClick.HasDelegate && args.Button == 0)
{
await TreeComponent.OnClick.InvokeAsync(new TreeEventArgs <TItem>(TreeComponent, SelfNode, args));
}
else if (TreeComponent.OnContextMenu.HasDelegate && args.Button == 2)
{
await TreeComponent.OnContextMenu.InvokeAsync(new TreeEventArgs <TItem>(TreeComponent, SelfNode, args));
}
TreeComponent.UpdateBindData();
}
void SpawnObject()
{
GameObject _newTreePiece;
if (SpawnOffsets.Count > 0)
{
_newTreePiece = Instantiate(PrefabsToSpawn[Random.Range(0, PrefabsToSpawn.Count)], transform.position + SpawnOffsets[Random.Range(0, SpawnOffsets.Count)], Quaternion.identity);
}
else
{
_newTreePiece = Instantiate(PrefabsToSpawn[Random.Range(0, PrefabsToSpawn.Count)], transform.position, Quaternion.identity);
}
TreeComponent _treeComponent = _newTreePiece.GetComponent <TreeComponent>();
_treeComponent.MoveSpeed = MoveSpeed;
_treeComponent.RotationSpeed = RotationSpeed;
}
/// <summary>
/// Create a new package gameobject with the specific informations.
/// </summary>
/// <returns></returns>
public GameObject GeneratePackage(TreeComponent packageComponent)
{
GameObject packageGameObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
packageGameObject.AddComponent <DirectoryInformation>();
packageGameObject.GetComponent <DirectoryInformation>().UpdateValues(packageComponent);
packageGameObject.AddComponent <ComponentClickListener>();
packageGameObject.GetComponentInChildren <Renderer>().sharedMaterial = contentMaterial;
packageGameObject.GetComponentInChildren <Renderer>().shadowCastingMode = ShadowCastingMode.Off;
packageGameObject.GetComponentInChildren <Renderer>().lightProbeUsage = LightProbeUsage.Off;
packageGameObject.GetComponentInChildren <Renderer>().reflectionProbeUsage = ReflectionProbeUsage.Off;
packageGameObject.GetComponentInChildren <Renderer>().receiveShadows = false;
packageGameObject.GetComponent <Collider>().enabled = false;
packageGameObject.GetComponent <Renderer>().enabled = false;
packageGameObject.name = packageComponent.Name;
return(packageGameObject);
}
private void FeedCategoryTree_CreateCategory(NewCategoryData newCategoryData)
{
var category = newCategoryData.Category;
if (category == null)
{
return;
}
var createdCategory = _categoryService.CreateCategory(category);
var treeComponent = new TreeComponent(createdCategory);
var parentComponent = newCategoryData.ParentTreeComponent ?? _subscriptionsComponent;
parentComponent.SubComponents.Add(treeComponent);
parentComponent.IsExpanded = true;
}
public void setMyComponents()
{
foreach (Transform t in components)
{
GameObject g = (GameObject)Instantiate(TreeGenerator.me.baseBranches [Random.Range(0, TreeGenerator.me.baseBranches.Count)], t.transform.position, Quaternion.Euler(0, 0, 0));
if (myComponents == null)
{
myComponents = new List <TreeComponent> ();
}
g.transform.parent = this.transform;
g.transform.position = new Vector3(g.transform.position.x, g.transform.position.y, Random.Range(g.transform.position.z, g.transform.position.z - 1.5f));
g.transform.rotation = Quaternion.Euler(0, 0, Random.Range(0, 360));
TreeComponent tc = g.GetComponent <TreeComponent>();
tc.setMyComponents(baseSortingOrder + 1);
myComponents.Add(tc);
}
}
private void FeedCategoryTree_DeleteItem(TreeComponent item)
{
switch (item.TreeComponentType)
{
case TreeComponentType.Category:
var category = item.Item as Category;
var deleteCategoryResult = MessageBox.Show(
$"Are you sure you want to delete category {category.Title}?",
"Delete category", MessageBoxButton.YesNo);
if (deleteCategoryResult == MessageBoxResult.No)
{
return;
}
_categoryService.DeleteCategory(category.CategoryId);
RemoveSubcomponentWithItem(_subscriptionsComponent, category);
_feedComponent.NewFeedItemsCountManual = _feedService.GetNewFeedItemsCount();
break;
case TreeComponentType.Channel:
var channel = item.Item as Channel;
var deleteChannelResult = MessageBox.Show(
$"Are you sure you want to delete channel {channel.Title}?",
"Delete channel", MessageBoxButton.YesNo);
if (deleteChannelResult == MessageBoxResult.No)
{
return;
}
_channelService.DeleteChannel(channel.ChannelId);
RemoveSubcomponentWithItem(_subscriptionsComponent, channel);
_feedComponent.NewFeedItemsCountManual = _feedService.GetNewFeedItemsCount();
break;
default:
break;
}
}
public void setMyComponents(int sortingOrder)
{
TreeGenerator tg = TreeGenerator.me;
foreach (Transform t in ComponentPoints)
{
int r = Random.Range(0, 100);
if (r < 25)
{
continue;
}
if (myType == TreeComponentType.branch)
{
GameObject g = (GameObject)Instantiate(tg.baseLeaves [Random.Range(0, tg.baseLeaves.Count)], t.transform.position, Quaternion.Euler(0, 0, 0));
if (components == null)
{
components = new List <TreeComponent> ();
}
g.transform.parent = this.transform;
g.transform.rotation = Quaternion.Euler(0, 0, Random.Range(0, 360));
TreeComponent tc = g.GetComponent <TreeComponent>();
tc.setMyComponents(sortingOrder + 1);
components.Add(tc);
g.GetComponent <SpriteRenderer> ().sortingOrder = sortingOrder;
}
else if (myType == TreeComponentType.trunk)
{
GameObject g = (GameObject)Instantiate(tg.baseBranches [Random.Range(0, tg.baseBranches.Count)], t.transform.position, Quaternion.Euler(0, 0, 0));
if (components == null)
{
components = new List <TreeComponent> ();
}
g.transform.parent = this.transform;
g.transform.rotation = Quaternion.Euler(0, 0, Random.Range(0, 360));
TreeComponent tc = g.GetComponent <TreeComponent>();
tc.setMyComponents(sortingOrder + 1);
components.Add(tc);
g.GetComponent <SpriteRenderer> ().sortingOrder = sortingOrder;
}
}
}
public override bool checkProceduralPrecondition(GameObject agent)
{
// find the nearest tree that we can chop
TreeComponent[] trees = (TreeComponent[])UnityEngine.GameObject.FindObjectsOfType(typeof(TreeComponent));
TreeComponent closest = null;
float closestDist = 0;
foreach (TreeComponent tree in trees)
{
if (tree.isInUse == false)
{
if (closest == null)
{
// first one, so choose it for now
closest = tree;
closestDist = (tree.gameObject.transform.position - agent.transform.position).magnitude;
}
else
{
// is this one closer than the last?
float dist = (tree.gameObject.transform.position - agent.transform.position).magnitude;
if (dist < closestDist)
{
// we found a closer one, use it
closest = tree;
closestDist = dist;
}
}
}
}
if (closest == null)
{
return(false);
}
targetTree = closest;
target = targetTree.gameObject;
targetTree.isInUse = true;
return(closest != null);
}
/// <summary>
/// Create a new document gameobject with the specific informations.
/// </summary>
/// <returns></returns>
public GameObject GenerateDocument(TreeComponent documentComponent, Metric[] selectedMetrics, float maxHeight)
{
GameObject documentGameObject = Instantiate(documentPrefab) as GameObject;
documentGameObject.AddComponent <FileInformation>();
documentGameObject.GetComponent <FileInformation>().UpdateValues(documentComponent);
documentGameObject.AddComponent <ComponentClickListener>();
documentGameObject.GetComponent <Renderer>().material = contentMaterial;
documentGameObject.GetComponent <Renderer>().shadowCastingMode = ShadowCastingMode.Off;
documentGameObject.GetComponent <Renderer>().lightProbeUsage = LightProbeUsage.Off;
documentGameObject.GetComponent <Renderer>().reflectionProbeUsage = ReflectionProbeUsage.Off;
documentGameObject.GetComponent <Renderer>().receiveShadows = false;
documentGameObject.GetComponent <Collider>().enabled = false;
documentGameObject.GetComponent <Renderer>().enabled = false;
documentGameObject.transform.position = Vector3.zero;
documentGameObject.name = documentComponent.Name;
if (((FilComponent)documentComponent).Language.Equals("xml"))
{
float widthDepth = FindSpecificMetricValue(selectedMetrics[0], documentComponent);
documentGameObject.transform.localScale = CalculateDocumentSize(widthDepth, 0.0f, maxHeight);
documentGameObject.GetComponent <Renderer>().material.color = Color.gray;
documentGameObject.GetComponent <MeshFilter>().mesh = this.gameObject.GetComponent <Cylinder>().Mesh();
}
else
{
float defaultMetric = FindSpecificMetricValue(selectedMetrics[0], documentComponent);
float heightMetric = FindSpecificMetricValue(selectedMetrics[1], documentComponent);
documentGameObject.transform.localScale = CalculateDocumentSize(defaultMetric, heightMetric, maxHeight);
float colorMetric = FindSpecificMetricValue(selectedMetrics[2], documentComponent);
documentGameObject.GetComponent <Renderer>().material.color = GetComponent <DocumentColorizer>().DocumentColor(colorMetric);
float pyramidMetric = FindSpecificMetricValue(selectedMetrics[3], documentComponent);
documentGameObject.GetComponent <MeshFilter>().mesh = CalculatePyramid(pyramidMetric);
}
return(documentGameObject);
}
private async void FeedCategoryTree_EditChannel(TreeComponent treeComponent)
{
var channel = treeComponent.Item as Channel;
if (channel == null)
{
return;
}
_channelService.UpdateChannel(channel);
await _feedUpdater.UpdateFeedAsync(channel.ChannelId);
UpdateChannelStats(channel.ChannelId, treeComponent);
var channelInTree = FindChannel(_subscriptionsComponent.SubComponents, channel.ChannelId);
if (channelInTree != null)
{
channelInTree.Item = channel;
channelInTree.Name = channel.Title;
}
}
public override bool CheckProceduralPrecondition(GameObject agent, BlackBoard bb)
{
// find the nearest tree that we can chop
TreeComponent[] trees = (TreeComponent[])bb.GetData("tree");
TreeComponent closest = null;
float closestDist = 0;
foreach (TreeComponent tree in trees)
{
if (closest == null)
{
// first one, so choose it for now
closest = tree;
closestDist = (tree.gameObject.transform.position - agent.transform.position).magnitude;
}
else
{
// is this one closer than the last?
float dist = (tree.gameObject.transform.position - agent.transform.position).magnitude;
if (dist < closestDist)
{
// we found a closer one, use it
closest = tree;
closestDist = dist;
}
}
}
if (closest == null)
{
return(false);
}
targetTree = closest;
target = targetTree.gameObject;
return(closest != null);
}
private async void FeedCategoryTree_CreateChannel(NewChannelData newChannelData)
{
var channel = newChannelData.Channel;
var parentComponent = newChannelData.ParentTreeComponent;
var category = (parentComponent?.Item as Category);
if (channel == null || parentComponent == null || category == null)
{
return;
}
channel.CategoryId = category.CategoryId;
var createdChannel = _channelService.CreateChannel(channel);
var treeComponent = new TreeComponent(createdChannel);
parentComponent.SubComponents.Add(treeComponent);
parentComponent.IsExpanded = true;
await _feedUpdater.UpdateFeedAsync(createdChannel.ChannelId);
UpdateChannelStats(createdChannel.ChannelId, treeComponent);
}
public override void reset()
{
finished = false;
targetTree = null;
startTime = 0;
}
public override void reset ()
{
chopped = false;
targetTree = null;
startTime = 0;
}
/// <summary>
/// Resets the action to its default values, so it can be used again.
/// </summary>
public override void Reset()
{
_chopped = false;
_targetTree = null;
StartTime = 0;
}
private void SetSelectedComponent(TreeComponent component, int selectedComponentID)
{
if (component == null)
{
return;
}
if (component.ID == selectedComponentID)
{
this.SelectedUser.SelectedComponent = component;
return;
}
foreach (TreeComponent childComponent in component.Components)
{
this.SetSelectedComponent(childComponent, selectedComponentID);
}
}
private void UpdateChannelStats(int channelId, TreeComponent treeComponent)
{
_feedComponent.NewFeedItemsCountManual = _feedService.GetNewFeedItemsCount();
treeComponent.NewFeedItemsCountManual = _feedService.GetNewFeedItemsCount(channelId);
}
/// <summary>
/// Resets the action to its default values, so it can be used again.
/// </summary>
public override void Reset()
{
_hasWood = false;
_targetTree = null;
StartTime = 0;
}
public override void Reset()
{
chopped = false;
targetTree = null;
startTime = 0;
}
/// <summary>
/// Update values.
/// </summary>
/// <param name="treeComponent"></param>
public override void UpdateValues(TreeComponent treeComponent)
{
base.UpdateValues(treeComponent);
this.language = ((TreeLeafComponent)treeComponent).Language;
}
public override void reset()
{
chopped = false;
startTime = 0;
closest = null;
}
private bool CheckAllSystemOptionPermission(TreeComponent Component, bool Value)
{
bool isAll = true;
if (SystemOptionPermissionID.Count == 0 || SystemOptionPermissionID.Contains(Component.ID))
{
foreach (var op in Component.OptionPermissions)
{
if (op.Type == OptionType.Flag)
{
if (!op.Flag.HasValue || op.Flag.Value != Value)
{
isAll = false;
break;
}
}
}
}
if (isAll)
{
foreach (TreeComponent cp in Component.Components)
{
isAll = CheckAllSystemOptionPermission(cp, Value);
if (!isAll)
{
break;
}
}
}
return isAll;
}
private void SetSystemOptionPermissionChanged(TreeComponent Component)
{
if (Component != null)
{
if (SystemOptionPermissionID.Count == 0 || SystemOptionPermissionID.Contains(Component.ID))
{
foreach (var op in Component.OptionPermissions)
{
op.OptionPermissionChanged += op_OptionPermissionChanged;
}
}
foreach (TreeComponent cp in Component.Components)
{
SetSystemOptionPermissionChanged(cp);
}
}
}
private void SetSystemOptionPermissionValues(TreeComponent Component, bool Value)
{
if (Component != null)
{
if (SystemOptionPermissionID.Count == 0 || SystemOptionPermissionID.Contains(Component.ID))
{
foreach (var op in Component.OptionPermissions)
{
if (op.Type == OptionType.Flag)
{
op.Flag = Value;
}
}
}
foreach (TreeComponent cp in Component.Components)
{
SetSystemOptionPermissionValues(cp, Value);
}
}
}
