Added champions items (first try)

match_collector/item_tree.ts

@@ -0,0 +1,89 @@
+type ItemTree = {
+    data: any
+    count: number
+    children: Array<ItemTree>
+};
+
+function treeInit() : ItemTree {
+    return {data:undefined, count:0, children:[]}
+}
+
+
+function treeNode(data : number, count : number) : ItemTree {
+    return {data:data, count:count, children:[]}
+}
+
+/*
+* Merge a node with an item tree
+*/
+function nodeMerge(itemtree : ItemTree, node : ItemTree) {
+    const item = node.data;
+    const count = node.count;
+    let next : ItemTree | null = null;
+
+    // Try to find an existing node in this tree level with same item
+    for(let node of itemtree.children) {
+        if(node.data == item) {
+            node.count += 1;
+            next = node;
+            break;
+        }
+    }
+
+    // If not found, add item node at this level
+    if(next == null) {
+        next = treeNode(item, count)
+        itemtree.children.push(next)
+    }
+
+    return next;
+}
+
+/* 
+* Merge a full build path with an existing item tree 
+*/
+function treeMerge(itemtree : ItemTree, items : Array<number>) {
+    let current = itemtree;
+
+    for(let item of items) {
+        current = nodeMerge(current, {data: item, count:1, children:[]})
+    }
+}
+
+function treeCutBranches(itemtree : ItemTree, thresholdCount : number, thresholdPerc : number) {
+    // Remove branches that are above threshold count
+    while(itemtree.children.length > thresholdCount) {
+        let leastUsedBranch = itemtree.children.reduce((a, b) => Math.min(a.count, b.count) == a.count ? a : b, {data:undefined, count: +Infinity, children: []})
+        itemtree.children.splice(itemtree.children.indexOf(leastUsedBranch), 1)
+    }
+
+    // Remove branches that are of too low usage
+    let toRemove : Array<ItemTree> = []
+    for(let child of itemtree.children) {
+        if((child.count/itemtree.count) < thresholdPerc) {
+            toRemove.push(child)
+        }
+    }
+    for(let tr of toRemove) {
+        itemtree.children.splice(itemtree.children.indexOf(tr), 1)
+    }
+
+    itemtree.children.map((x) => treeCutBranches(x, thresholdCount, thresholdPerc))
+}
+
+function treeMergeTree(itemtree1: ItemTree, itemtree2: ItemTree) {
+    for(let child of itemtree2.children) {
+        let node = nodeMerge(itemtree1, child)
+        treeMergeTree(node, child)
+    }
+}
+
+function treeSort(itemtree: ItemTree) {
+    itemtree.children.sort((a, b) => b.count - a.count)
+
+    for(let item of itemtree.children) {
+        treeSort(item)
+    }
+}
+
+export {ItemTree, treeMerge, treeInit, treeCutBranches, treeSort}