Example #1
0
        public override void UpdateClusters()
        {
            CurrentClusters.Clear();

            //Get unit objects only!
            List <CacheUnit> listObjectUnits = Bot.Targeting.Cache.ValidObjects.OfType <CacheUnit>().Where(u =>
                                                                                                           Bot.Targeting.Cache.Environment.UnitRAGUIDs.Contains(u.RAGUID) &&
                                                                                                           u.CentreDistance <= this.clusterConditions.MaximumDistance &&
                                                                                                           (!this.clusterConditions.IgnoreNonTargetable || u.IsTargetable.HasValue && u.IsTargetable.Value)).ToList();


            //Logger.DBLog.InfoFormat("Total Units {0}", listObjectUnits.Count.ToString());
            if (listObjectUnits.Count > 0)
            {
                CurrentClusters = cluster.RunKmeans(listObjectUnits, this.clusterConditions.ClusterDistance).Where(c => c.ListUnits.Count >= this.clusterConditions.MinimumUnits && (this.clusterConditions.DOTDPSRatio == 0.00d || c.Info.DotDPSRatio <= this.clusterConditions.DOTDPSRatio)).ToList();

                //Sort by distance -- reverse to get nearest unit First
                if (CurrentClusters.Count > 0)
                {
                    CurrentClusters = CurrentClusters.OrderBy(o => o.NearestMonsterDistance).ToList();
                    CurrentClusters.First().ListUnits.Sort();
                    CurrentClusters.First().ListUnits.Reverse();
                }
            }

            lastClusterComputed = DateTime.Now;
        }
Example #2
0
        ///<summary>
        ///Updates the Cluster List!
        ///</summary>
        public virtual void UpdateClusters()
        {
            CurrentClusters.Clear();
            //Get unit objects only!
            List <CacheUnit> listObjectUnits;

            //(radius or centre)
            if (!clusterConditions.UseRadiusDistance)
            {
                listObjectUnits = FunkyGame.Targeting.Cache.ValidObjects.OfType <CacheUnit>().Where(u =>
                                                                                                    FunkyGame.Targeting.Cache.Environment.UnitRAGUIDs.Contains(u.RAGUID) &&
                                                                                                    u.CentreDistance <= clusterConditions.MaximumDistance &&
                                                                                                    u.CentreDistance >= clusterConditions.MinimumDistance &&
                                                                                                    (!clusterConditions.IgnoreNonTargetable || u.IsTargetable.HasValue && u.IsTargetable.Value)).ToList();
            }
            else
            {
                listObjectUnits = FunkyGame.Targeting.Cache.ValidObjects.OfType <CacheUnit>().Where(u =>
                                                                                                    FunkyGame.Targeting.Cache.Environment.UnitRAGUIDs.Contains(u.RAGUID) &&
                                                                                                    u.RadiusDistance <= clusterConditions.MaximumDistance &&
                                                                                                    u.RadiusDistance >= clusterConditions.MinimumDistance &&
                                                                                                    (!clusterConditions.IgnoreNonTargetable || u.IsTargetable.HasValue && u.IsTargetable.Value)).ToList();
            }


            //Logger.DBLog.InfoFormat("Total Units {0}", listObjectUnits.Count.ToString());
            if (listObjectUnits.Count > 0)
            {
                CurrentClusters = cluster.RunKmeans(listObjectUnits, clusterConditions.ClusterDistance)
                                  .Where(c => c.Info.Properties.HasFlag(clusterConditions.ClusterFlags) && c.ListUnits.Count >= clusterConditions.MinimumUnits && (clusterConditions.DOTDPSRatio == 0.00d || c.Info.DotDPSRatio <= clusterConditions.DOTDPSRatio)).ToList();

                //Sort by distance -- reverse to get nearest unit First
                if (CurrentClusters.Count > 0)
                {
                    CurrentClusters = CurrentClusters.OrderBy(o => o.NearestMonsterDistance).ToList();
                    CurrentClusters.First().ListUnits.Sort();
                    CurrentClusters.First().ListUnits.Reverse();
                }
            }

            lastClusterComputed = DateTime.Now;
        }
Example #3
0
        ///<summary>
        ///Iterates thru the cluster list and calls the update method on each.
        ///</summary>
        public virtual void RefreshClusters()
        {
            if (DateTime.Now.Subtract(lastClusterRefresh).TotalMilliseconds < this.RefreshRate)
            {
                return;
            }


            if (CurrentClusters.Count > 0)
            {
                foreach (var item in CurrentClusters)
                {
                    item.UpdateUnitPointLists(clusterConditions);
                }

                CurrentClusters = CurrentClusters.Where(c => c.ListUnits.Count >= clusterConditions.MinimumUnits && (clusterConditions.DOTDPSRatio == 0.00d || c.Info.DotDPSRatio <= clusterConditions.DOTDPSRatio)).ToList();
            }

            lastClusterRefresh = DateTime.Now;
        }
        private void MergeClusters(string linkageMethod, string distanceMethod)
        {
            double  minDist = double.MaxValue;
            Cluster minClust1 = null, minClust2 = null;
            bool    buildInitialMatrix = false;

            if (distanceMatrix.Count == 0)
            {
                buildInitialMatrix = true;
            }

            for (int i = 0; i < CurrentClusters.Count; ++i)
            {
                Cluster c1 = CurrentClusters[i];

                if (buildInitialMatrix)
                {
                    distanceMatrix[c1] = new Dictionary <Cluster, double>();
                }

                for (int j = i + 1; j < CurrentClusters.Count; ++j)
                {
                    Cluster c2 = CurrentClusters[j];
                    double  dist;

                    if (buildInitialMatrix)
                    {
                        dist = distanceMatrix[c1][c2] = ClusterDistance(CurrentClusters[i], CurrentClusters[j], linkageMethod, distanceMethod);
                    }
                    else
                    {
                        dist = distanceMatrix[CurrentClusters[i]][CurrentClusters[j]];
                    }

                    if (dist < minDist)
                    {
                        minDist   = dist;
                        minClust1 = CurrentClusters[i];
                        minClust2 = CurrentClusters[j];
                    }
                }
            }

            if (minClust1 == null || minClust2 == null)
            {
                Console.WriteLine("[WARNING] Could not find clusters to merge");
                return;
            }

            Cluster newCluster = new Cluster(minClust1, minClust2);

            FinalClusters.Add(minClust1);
            FinalClusters.Add(minClust2);

            CurrentClusters.Remove(minClust1);
            CurrentClusters.Remove(minClust2);

            // update distance matrix and add new cluster to current clusters
            distanceMatrix.Remove(minClust1);
            distanceMatrix.Remove(minClust2);

            foreach (Cluster c in CurrentClusters)
            {
                distanceMatrix[c][newCluster] = ClusterDistance(c, newCluster, linkageMethod, distanceMethod);
            }

            distanceMatrix[newCluster] = new Dictionary <Cluster, double>();
            CurrentClusters.Add(newCluster);
        }