public double GetDesirability(float hunger, float fatique)
        {
            fuzzyModule.Fuzzify("Hunger", hunger);
            fuzzyModule.Fuzzify("Fatique", fatique);

            return(fuzzyModule.DeFuzzify("Desirability"));
        }
Exemple #2
0
 /* Right now the calculate function only relies on 2 input sets and 1 output set... */
 public static double calculate(FuzzyModule module, string xname, double xval, string yname, double yval, string outname)
 {
     module.Fuzzify(xname, ref xval);
     module.Fuzzify(yname, ref yval);
     Console.WriteLine(module.VarMap[xname]);
     Console.WriteLine(module.VarMap[yname]);
     return(module.Defuzzify(outname, FuzzyModule.DefuzzifyType.CENTROID));
 }
Exemple #3
0
 public double GetDesirability(float distance)
 {
     // Fuzzify antecedent 1
     fm.Fuzzify("DistToRegion", distance);
     // Fuzzify antecedent 2
     fm.Fuzzify("RegionWealth", resourceCount);
     // Defuzzify consequence
     return(fm.DeFuzzify("Desirability"));
 }
Exemple #4
0
        /// <summary>
        ///  Retrieves target with the highest desirability and uses the weapon with the highest desirability to attack the Enemy.
        /// </summary>
        /// <returns>Enemy to attack</returns>
        public Enemy GetDesiredTarget()
        {
            Enemy  toReturn       = null;
            double highestOverall = -1;

            foreach (Enemy e in GameWorld.Instance.enemies)
            {
                double highestForThisLoop;
                if (position.Distance(e.pos) < (sniper.attackRange + 1) * BaseTile.size && !e.dead)
                {
                    double shotgunDesirability = 0;

                    if (position.Distance(e.pos) < (shotgun.attackRange + 1) * BaseTile.size)
                    {
                        towerShotgunFuzzyModule.Fuzzify("Health", e.health / e.maxHealth * 100);
                        towerShotgunFuzzyModule.Fuzzify("DistanceToEnemy", position.Distance(e.pos) / ((sniper.attackRange + 1) * BaseTile.size) * 100);
                        shotgunDesirability = towerShotgunFuzzyModule.DeFuzzify("ShootDesirability", DefuzzifyMethod.MAX_AV);
                    }
                    double sniperDesirability;
                    towerSniperFuzzyModule.Fuzzify("Health", e.health / e.maxHealth * 100);
                    towerSniperFuzzyModule.Fuzzify("DistanceToEnemy", position.Distance(e.pos) / ((sniper.attackRange + 1) * BaseTile.size) * 100);
                    sniperDesirability = towerSniperFuzzyModule.DeFuzzify("ShootDesirability", DefuzzifyMethod.MAX_AV);

                    if (shotgunDesirability > sniperDesirability)
                    {
                        highestForThisLoop = shotgunDesirability;
                        if (highestForThisLoop > highestOverall)
                        {
                            weapon = shotgun;
                        }
                    }
                    else
                    {
                        highestForThisLoop = sniperDesirability;
                        if (highestForThisLoop > highestOverall)
                        {
                            weapon = sniper;
                        }
                    }
                    if (highestForThisLoop > highestOverall)
                    {
                        highestOverall = highestForThisLoop;
                        toReturn       = e;
                        Console.WriteLine(sniperDesirability + " " + shotgunDesirability);
                        if (!enemiesInRange.Contains(e))
                        {
                            Console.WriteLine(weapon);
                        }
                    }
                }
            }
            return(toReturn);
        }
Exemple #5
0
        public override float GetDesirability(float distanceToTarget)
        {
            // fuzzify distance and amount of ammo
            FuzzyModule.Fuzzify("distanceToTarget", distanceToTarget);

            LastDesirabilityScore =
                FuzzyModule.DeFuzzify("desirability", FuzzyModule.DefuzzifyMethod.MaxAv);

            return(LastDesirabilityScore);
        }
        public void FuzzyLogic_Test1()
        {
            FuzzyModule fuzzyModule = new FuzzyModule();

            FuzzyVariable distanceToTarget = fuzzyModule.CreateFLV("DistanceToTarget");
            FzSet         Target_Close     = distanceToTarget.AddLeftShoulderSet("Target_Close", 0, 250, 500);
            FzSet         Target_Medium    = distanceToTarget.AddTriangularSet("Target_Medium", 250, 500, 750);
            FzSet         Target_Far       = distanceToTarget.AddRightShoulderSet("Target_Far", 500, 750, 1000);

            FuzzyVariable AmmoStatus = fuzzyModule.CreateFLV("AmmoStatus");
            FzSet         Ammo_Low   = AmmoStatus.AddLeftShoulderSet("Ammo_Low", 0, 250, 500);
            FzSet         Ammo_Okay  = AmmoStatus.AddTriangularSet("Ammo_Okay", 250, 500, 750);
            FzSet         Ammo_Loads = AmmoStatus.AddRightShoulderSet("Ammo_Loads", 500, 750, 1000);

            FuzzyVariable Desirability   = fuzzyModule.CreateFLV("Desirability");
            FzSet         Undesirable    = Desirability.AddLeftShoulderSet("Undesirable", 0, 25, 50);
            FzSet         Desirable      = Desirability.AddTriangularSet("Desirable", 25, 50, 75);
            FzSet         Very_Desirable = Desirability.AddRightShoulderSet("Very_Desirable", 50, 75, 100);

            fuzzyModule.AddRule(new FzAND(Target_Close, Ammo_Loads), Undesirable);
            fuzzyModule.AddRule(new FzAND(Target_Close, Ammo_Okay), Undesirable);
            fuzzyModule.AddRule(new FzAND(Target_Close, Ammo_Low), Undesirable);
            fuzzyModule.AddRule(new FzAND(Target_Medium, Ammo_Loads), Very_Desirable);
            fuzzyModule.AddRule(new FzAND(Target_Medium, Ammo_Okay), Very_Desirable);
            fuzzyModule.AddRule(new FzAND(Target_Medium, Ammo_Low), Desirable);
            fuzzyModule.AddRule(new FzAND(Target_Far, Ammo_Loads), Desirable);
            fuzzyModule.AddRule(new FzAND(Target_Far, Ammo_Okay), Desirable);
            fuzzyModule.AddRule(new FzAND(Target_Far, Ammo_Low), Undesirable);

            fuzzyModule.Fuzzify("DistanceToTarget", 200);
            fuzzyModule.Fuzzify("AmmoStatus", 400);

            double value = fuzzyModule.DeFuzzify("Desirability", FuzzyModule.DefuzzifyMethod.MaxAV);

            Assert.Equal(12.5, value);

            fuzzyModule.Fuzzify("DistanceToTarget", 1000);
            fuzzyModule.Fuzzify("AmmoStatus", 600);

            value = fuzzyModule.DeFuzzify("Desirability", FuzzyModule.DefuzzifyMethod.MaxAV);

            Assert.Equal(50, value);
        }
    public double FuzzyGetDesirabilitySeek(int hungerVar, double moneyVar)
    {
        FuzzyModule fuzzyModule = new FuzzyModule();

        FuzzyVariable hunger      = fuzzyModule.CreateFLV("Hunger");
        FzSet         No_Hunger   = hunger.AddLeftShoulderSet("No_Hunger", 0, 5, 10);
        FzSet         Hunger      = hunger.AddTriangularSet("Hunger", 5, 10, 15);
        FzSet         Very_Hunger = hunger.AddRightShoulderSet("Very_Hunger", 10, 15, 20);

        FuzzyVariable AmmoStatus = fuzzyModule.CreateFLV("Money");
        FzSet         Poor       = AmmoStatus.AddLeftShoulderSet("Poor", 0, 5, 10);
        FzSet         Normal     = AmmoStatus.AddTriangularSet("Normal", 5, 10, 100);
        FzSet         Rich       = AmmoStatus.AddRightShoulderSet("Rich", 10, 100, 1000);

        FuzzyVariable Desirability   = fuzzyModule.CreateFLV("Desirability");
        FzSet         Undesirable    = Desirability.AddLeftShoulderSet("Undesirable", 0, 25, 50);
        FzSet         Desirable      = Desirability.AddTriangularSet("Desirable", 25, 50, 75);
        FzSet         Very_Desirable = Desirability.AddRightShoulderSet("Very_Desirable", 50, 75, 100);

        fuzzyModule.AddRule(new FzAND(No_Hunger, Poor), Undesirable);
        fuzzyModule.AddRule(new FzAND(No_Hunger, Normal), Undesirable);
        fuzzyModule.AddRule(new FzAND(No_Hunger, Rich), Undesirable);
        fuzzyModule.AddRule(new FzAND(Very_Hunger, Poor), Very_Desirable);
        fuzzyModule.AddRule(new FzAND(Very_Hunger, Normal), Very_Desirable);
        fuzzyModule.AddRule(new FzAND(Very_Hunger, Rich), Undesirable);
        fuzzyModule.AddRule(new FzAND(Hunger, Poor), Desirable);
        fuzzyModule.AddRule(new FzAND(Hunger, Normal), Desirable);
        fuzzyModule.AddRule(new FzAND(Hunger, Rich), Undesirable);

        fuzzyModule.Fuzzify("Hunger", hungerVar);
        fuzzyModule.Fuzzify("Money", moneyVar);

        double value = fuzzyModule.DeFuzzify("Desirability", FuzzyModule.DefuzzifyMethod.MaxAV);

        return(value);
    }
Exemple #8
0
        public override float GetDesirability(float distanceToTarget)
        {
            if (RoundsRemaining == 0)
            {
                LastDesirabilityScore = 0;
            }
            else
            {
                // fuzzify distance and amount of ammo
                FuzzyModule.Fuzzify("distanceToTarget", distanceToTarget);
                FuzzyModule.Fuzzify("ammoStatus", RoundsRemaining);
                LastDesirabilityScore =
                    FuzzyModule.DeFuzzify("desirability", FuzzyModule.DefuzzifyMethod.MaxAv);
            }

            return(LastDesirabilityScore);
        }
Exemple #9
0
        static void Main(string[] args)
        {
            Console.WriteLine("hello {0}", "John");

            FuzzyModule   fm           = new FuzzyModule();
            FuzzyVariable Dist2Target  = fm.CreateFLV("Dist2Target");
            FuzzyVariable Desirability = fm.CreateFLV("Desirability");
            FuzzyVariable AmmoStatus   = fm.CreateFLV("AmmoStatus");

            FzSet Target_Close = Dist2Target.AddLeftShoulderSet("Target_Close",
                                                                0, 25, 150);
            FzSet Target_Medium = Dist2Target.AddTrianglularSet("Target_Medium",
                                                                25, 150, 300);
            FzSet Target_Far = Dist2Target.AddRightShoulderSet("Target_Far",
                                                               150, 300, 400);

            FzSet Ammon_low = AmmoStatus.AddLeftShoulderSet("Ammon_low",
                                                            0, 0, 10);
            FzSet Ammon_Okay = AmmoStatus.AddTrianglularSet("Ammon_Okay",
                                                            0, 10, 30);
            FzSet Ammon_Loads = AmmoStatus.AddRightShoulderSet("Ammon_Loads",
                                                               10, 30, 40);

            FzSet Undesirable = Desirability.AddLeftShoulderSet("Undesirable",
                                                                0, 25, 50);
            FzSet Desirable = Desirability.AddTrianglularSet("Desirable",
                                                             25, 50, 75);
            FzSet VeryDesirable = Desirability.AddRightShoulderSet("VeryDesirable",
                                                                   50, 75, 100);

            bool Combos = true;

            if (Combos)
            {
                fm.AddRule((Target_Far), Undesirable);
                fm.AddRule((Target_Medium), VeryDesirable);
                fm.AddRule((Target_Close), Undesirable);
                fm.AddRule((Ammon_Loads), VeryDesirable);
                fm.AddRule((Ammon_Okay), Desirable);
                fm.AddRule((Ammon_low), Undesirable);

                //fm.AddRule(new FzFairly(Target_Far), Undesirable);
                //fm.AddRule(new FzFairly(Target_Medium), VeryDesirable);
                //fm.AddRule(new FzFairly(Target_Close), Undesirable);
                //fm.AddRule(new FzFairly(Ammon_Loads), VeryDesirable);
                //fm.AddRule(new FzFairly(Ammon_Okay), Desirable);
                //fm.AddRule(new FzFairly(Ammon_low), Undesirable);

                //fm.AddRule(new FzVery(Target_Far), Undesirable);
                //fm.AddRule(new FzVery(Target_Medium), VeryDesirable);
                //fm.AddRule(new FzVery(Target_Close), Undesirable);
                //fm.AddRule(new FzVery(Ammon_Loads), VeryDesirable);
                //fm.AddRule(new FzVery(Ammon_Okay), Desirable);
                //fm.AddRule(new FzVery(Ammon_low), Undesirable);
            }
            else
            {
                fm.AddRule(new FzAND(Target_Far, Ammon_Loads), Desirable);
                fm.AddRule(new FzAND(Target_Far, Ammon_Okay), Undesirable);
                fm.AddRule(new FzAND(Target_Far, Ammon_low), Undesirable);

                fm.AddRule(new FzAND(Target_Medium, Ammon_Loads), VeryDesirable);
                fm.AddRule(new FzAND(Target_Medium, Ammon_Okay), VeryDesirable);
                fm.AddRule(new FzAND(Target_Medium, Ammon_low), Desirable);

                fm.AddRule(new FzAND(Target_Close, Ammon_Loads), Undesirable);
                fm.AddRule(new FzAND(Target_Close, Ammon_Okay), Undesirable);
                fm.AddRule(new FzAND(Target_Close, Ammon_low), Undesirable);
            }

            fm.Fuzzify("Dist2Target", 200);
            fm.Fuzzify("AmmoStatus", 8);

            double result = fm.Defuzzify("Desirability", FuzzyModule.DefuzzifyMethod.max_av);

            Console.WriteLine("Dist2Target is {0}", fm.Defuzzify("Dist2Target", FuzzyModule.DefuzzifyMethod.max_av));
            Console.WriteLine("AmmoStatus is {0}", fm.Defuzzify("AmmoStatus", FuzzyModule.DefuzzifyMethod.max_av));
            Console.WriteLine("Desirability is {0}", result);
        }
Exemple #10
0
 public virtual double GetDesirability(float distToTarget)
 {
     fm.Fuzzify("DistToTarget", distToTarget);
     fm.Fuzzify("Durability", stats.durability);
     return(fm.DeFuzzify("Desirability"));
 }
 public double GetDesirability(double hunger, double sleep)
 {
     fuzzyModule.Fuzzify("Hunger", hunger);
     fuzzyModule.Fuzzify("Sleep", sleep);
     return(fuzzyModule.DeFuzzify("Desirability"));;
 }