Example #1
0
 /// <summary>
 /// Verfolgt das aktuelle Ziel weiter oder geht geradeaus, wenn kein Ziel vorhanden.
 /// </summary>
 private void Weitermachen()
 {
     if (Ziel != null)
     {
         if (Ziel.GetType() == typeof(Insekt))
         {
             GreifeAn((Insekt)Ziel);
             greiftAn = true;
         }
         else
         {
             GeheZuZiel(Ziel);
         }
     }
     else
     {
         if (FuzzyInferenceSystem.Superdecision5x5x2(character.faulheit, character.energie, character.laufen, memory.GetDecisionValue(DecisionType.Laufen)))
         {
             GeheGeradeaus();
         }
         else
         {
             //kein Bock
             BleibStehen();
             WaitUntil(50);
         }
     }
 }
Example #2
0
        /// <summary>
        /// Wird wiederholt aufgerufen, wenn die Ameise mindestens eine Ameise eines
        /// anderen Volkes sieht.
        /// </summary>
        /// <param name="ameise">Die nächstgelegen feindliche Ameise.</param>
        public override void SiehtFeind(Ameise ameise)
        {
            if (/*!trägtNahrung //rauskommentiert, damit feindliche Ameisen den Apfel nicht wegtragen können &&*/ !greiftAn)
            {
                if (FuzzyInferenceSystem.Superdecision5x5x2(character.wut, character.energie, character.angreifen, memory.GetDecisionValue(DecisionType.AngreifenAmeise)))
                {
                    //Hilfe rufen
                    SprüheMarkierung(Markers.Add(new Marker(Marker.MarkerType.HilfeAmeise, ameise)), MarkierungGrößeHilfeLokal);

                    //evtl. Nahrung fallen lassen
                    if (trägtNahrung)
                    {
                        LasseNahrungFallen();
                        trägtNahrung = false;
                    }

                    //Angreifen
                    GreifeAn(ameise);
                    greiftAn = true;
                    memory.ActionDone(DecisionType.AngreifenAmeise);
                    setActionBreak();
                }
                else
                {
                    Weitermachen();
                }
            }
            else
            {
                Weitermachen();
            }
        }
Example #3
0
 /// <summary>
 /// Wird wiederholt aufgerufen, wenn die Ameise von einer Wanze angegriffen
 /// wird.
 /// </summary>
 /// <param name="wanze">Die angreifende Wanze.</param>
 public override void WirdAngegriffen(Wanze wanze)
 {
     /*
      * SprüheMarkierung((int)Information.Hilfe, MarkierungGrößeHilfe);
      * GreifeAn(wanze);
      * greiftAn = true;
      */
     //Entscheidung Angreifen
     //Wenn negativ, Entscheidung wegrennen
     if (FuzzyInferenceSystem.Superdecision5x5x2(character.wut, character.ameisenFreundeInNaehe, character.angreifen, memory.GetDecisionValue(1 - DecisionType.Wegrennen))) //beeinflusst Entscheidung zum Angriff negativ
     {
         GreifeAn(wanze);
         greiftAn = true;
         memory.ActionDone(DecisionType.AngreifenWanze);
         setActionBreak();
     }
     else
     {
         LasseNahrungFallen();
         trägtNahrung = false;
         memory.ActionDone(DecisionType.Wegrennen);
         setActionBreak();
         GeheZuBau();
     }
 }
Example #4
0
 /// <summary>
 /// Wird wiederholt aufgerufen, wenn die Ameise mindstens eine Ameise des
 /// selben Volkes sieht.
 /// </summary>
 /// <param name="ameise">Die nächstgelegene befreundete Ameise.</param>
 public override void SiehtFreund(Ameise ameise)
 {
     if (!(this.EntfernungZuBau == 0))
     {
         if (Ziel == null)
         {
             //grupperen entscheiden
             if (FuzzyInferenceSystem.Superdecision5x5x2(character.teamfaehigkeit, character.energie, character.gruppieren, memory.GetDecisionValue(DecisionType.Gruppieren)))
             {
                 this.GeheZuZiel(ameise);
                 memory.ActionDone(DecisionType.Gruppieren);
                 setActionBreak();
             }
             else
             {
                 Weitermachen();
             }
         }
         else
         {
             Weitermachen();
         }
     }
     else
     {
         Weitermachen();
     }
 }
Example #5
0
        /// <summary>
        /// Wird wiederholt aufgerufen, wenn die Ameise mindstens ein
        /// Obststück sieht.
        /// </summary>
        /// <param name="obst">Das nächstgelegene Obststück.</param>
        public override void Sieht(Obst obst)
        {
            if (!trägtNahrung)
            {
                if (FuzzyInferenceSystem.Superdecision5x5x2(character.faulheit, character.energie, character.sammelnobst, memory.GetDecisionValue(DecisionType.SammelnObst))) // && FuzzyInferenceSystem.Superdecision5x5x2(character.teamfaehigkeit, character.ameisenFreundeInNaehe, character.sammelnobst, memory.GetDecisionValue(DecisionType.Gruppieren)))
                {
                    GeheZuZiel(obst);
                    memory.ActionDone(DecisionType.SammelnObst);
                    memory.ActionDone(DecisionType.Gruppieren);
                    setActionBreak();

                    //SprüheMarkierung
                    SprüheMarkierung(Markers.Add(new Marker(Marker.MarkerType.HilfeObst, obst)), MarkierungGrößeHilfeLokal);
                }
                else
                {
                    //kein Bock
                    Weitermachen();
                }
            }
            else
            {
                //trägt Nahrung
                //Weitermachen();
                GeheZuBau();
            }
        }
Example #6
0
        /// <summary>
        /// Wird wiederholt aufgerufen, wenn die Ameise mindestens eine Wanze
        /// sieht.
        /// </summary>
        /// <param name="wanze">Die nächstgelegene Wanze.</param>
        public override void SiehtFeind(Wanze wanze)
        {
            if (!trägtNahrung && !greiftAn)
            {
                if (FuzzyInferenceSystem.CorrelateDecisionfunctions(FuzzyInferenceSystem.Superdecision5x5x2_Double(character.wut, character.energie, character.angreifen, memory.GetDecisionValue(DecisionType.AngreifenWanze)), FuzzyInferenceSystem.Superdecision5x5x2_Double(character.teamfaehigkeit, character.ameisenFreundeInNaehe, character.angreifen, memory.GetDecisionValue(DecisionType.AngreifenWanze))))
                {
                    //hilfe rufen
                    SprüheMarkierung(Markers.Add(new Marker(Marker.MarkerType.HilfeWanze, wanze)), MarkierungGrößeHilfe);

                    //angreifen
                    GreifeAn(wanze);
                    greiftAn = true;
                    memory.ActionDone(DecisionType.AngreifenWanze);
                    setActionBreak();
                }
                else
                {
                    //Entscheidung wegrennen
                    GeheWegVon(wanze);
                    memory.ActionDone(DecisionType.Wegrennen);
                    setActionBreak();
                }
            }
            else
            {
                Weitermachen();
            }
        }
Example #7
0
        /// <summary>
        /// Wird wiederholt aufgerufen, wenn der die Ameise nicht weiss wo sie
        /// hingehen soll.
        /// </summary>
        public override void Wartet()
        {
            if (currentFrame <= waitForFrame)
            {
                return;
            }
            //Hat die Ameise etwas gemacht?


            if (EntfernungZuBau == 0)
            {
                if (greiftAn)
                {
                    greiftAn = false;
                    memory.ActionSuccessful();
                }

                if (trägtNahrung)
                {
                    trägtNahrung = false;
                    memory.ActionSuccessful();
                }

                if (hilftFreund)
                {
                    hilftFreund = false;
                    memory.ActionSuccessful();
                }
                //Entscheiden, ob letzter Zucker gesucht werden soll
                if (Memory.gemerkterZucker != null)
                {
                    if (FuzzyInferenceSystem.Superdecision5x5x2(character.faulheit, character.energie, character.sammelnzucker, memory.GetDecisionValue(DecisionType.SammelnZucker)))
                    {
                        //Zucker sammeln
                        GeheZuZiel(Memory.gemerkterZucker);

                        if (memory.LastAction != DecisionType.Laufen)
                        {
                            memory.ActionDone(DecisionType.Laufen);
                        }

                        memory.ActionDone(DecisionType.SammelnZucker);
                        setActionBreak();
                    }
                    else
                    {
                        //Entscheiden, ob die Ameise laufen soll
                        Weitermachen();
                    }
                }
            }
            else
            {
                Weitermachen();
            }
        }
Example #8
0
        /// <summary>
        /// Verfolgt das aktuelle Ziel weiter oder geht geradeaus, wenn kein Ziel vorhanden.
        /// </summary>
        private void Weitermachen()
        {
            if (Ziel != null)
            {
                if (Ziel.GetType() == typeof(Insekt))
                {
                    GreifeAn((Insekt)Ziel);
                    greiftAn = true;
                }
                else
                {
                    GeheZuZiel(Ziel);
                }
            }
            else
            {
                if (FuzzyInferenceSystem.Superdecision5x5x2(character.faulheit, character.energie, character.laufen, memory.GetDecisionValue(DecisionType.Laufen)))
                {
                    if (AltesZiel != null)
                    {
                        GeheZuZiel(AltesZiel);

                        //Zucker kann immer als Ziel beibehalten werden
                        if (AltesZiel.GetType() != typeof(Zucker))
                        {
                            AltesZiel = null;
                        }
                    }
                    else
                    {
                        //Kein Ziel gemerkt
                        GeheGeradeaus();
                        setActionBreak();
                        if (memory.LastAction != DecisionType.Laufen)
                        {
                            memory.ActionDone(DecisionType.Laufen);
                        }
                    }
                }
                else
                {
                    //kein Bock
                    BleibStehen();
                    WaitUntil(50);

                    if (memory.LastAction != DecisionType.Warten)
                    {
                        memory.ActionDone(DecisionType.Warten);
                    }
                }
            }
        }
Example #9
0
        /// <summary>
        /// Wird wiederholt aufgerufen, wenn die Ameise mindestens eine Wanze
        /// sieht.
        /// </summary>
        /// <param name="wanze">Die nächstgelegene Wanze.</param>
        public override void SiehtFeind(Wanze wanze)
        {
            if (!trägtNahrung && !greiftAn)
            {
                if (FuzzyInferenceSystem.Superdecision5x5x2(character.wut, character.energie, character.angreifen, memory.GetDecisionValue(DecisionType.AngreifenWanze)))
                {
                    if (FuzzyInferenceSystem.Superdecision5x5x2(character.wut, character.ameisenFreundeInNaehe, character.angreifen, memory.GetDecisionValue(DecisionType.AngreifenWanze)))
                    {
                        //hilfe rufen
                        SprüheMarkierung(Markers.Add(new Marker(Marker.MarkerType.HilfeWanze, wanze)), MarkierungGrößeHilfe);

                        //angreifen
                        GreifeAn(wanze);
                        greiftAn = true;
                        memory.ActionDone(DecisionType.AngreifenWanze);
                        setActionBreak();
                    }
                    else
                    {
                        //wegrennen
                        //Entscheidung wegrennen
                        //GeheZuBau();
                        //memory.ActionDone(DecisionType.Wegrennen);
                        Weitermachen();
                    }
                }
            }
            else
            {
                //wegrennen
                //Entscheidung flüchten? -> Nahrung sofort fallen lassen

                /*if (EntfernungZuBau == 0)
                 * {
                 *  LasseNahrungFallen();
                 *  trägtNahrung = false;
                 *  GeheZuBau();
                 * }*/

                //speichern, dass Ameise bereits weggerannt ist?
                //memory.ActionDone(DecisionType.Wegrennen);

                Weitermachen();
            }
        }
Example #10
0
 /// <summary>
 /// Wird wiederholt aufgerufen in der die Ameise von einer Ameise eines
 /// anderen Volkes Ameise angegriffen wird.
 /// </summary>
 /// <param name="ameise">Die angreifende feindliche Ameise.</param>
 public override void WirdAngegriffen(Ameise ameise)
 {
     //Entscheidung Angreifen
     //Wenn negativ, Entscheidung wegrennen
     if (FuzzyInferenceSystem.Superdecision5x5x2(character.wut, character.energie, character.angreifen, memory.GetDecisionValue(DecisionType.AngreifenAmeise)))
     {
         GreifeAn(ameise);
         greiftAn = true;
         memory.ActionDone(DecisionType.AngreifenAmeise);
         setActionBreak();
     }
     else
     {
         GeheWegVon(ameise);
         memory.ActionDone(DecisionType.Wegrennen);
         setActionBreak();
     }
 }
Example #11
0
        /// <summary>
        /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen
        /// Zuckerhaufen sieht.
        /// </summary>
        /// <param name="zucker">Der nächstgelegene Zuckerhaufen.</param>
        public override void Sieht(Zucker zucker)
        {
            //Alle Ameisen sollen Zucker kennen
            if (Memory.gemerkterZucker == null)
            {
                Memory.gemerkterZucker = zucker;
            }
            else
            {
                //aktueller Zucker näher ran? -> in ZielErreicht(zucker) prüfen
                //aktueller Zucker voller?
                //-> neuen Zucker merken
                if (Memory.gemerkterZucker.Menge == 0)
                {
                    Memory.gemerkterZucker = zucker;
                }
            }

            if (!trägtNahrung)
            {
                if (FuzzyInferenceSystem.Superdecision5x5x2(character.faulheit, character.energie, character.sammelnzucker, memory.GetDecisionValue(DecisionType.SammelnZucker)))
                {
                    //SprüheMarkierung
                    SprüheMarkierung(Markers.Add(new Marker(Marker.MarkerType.Zucker, zucker)), MarkierungGrößeInformation);

                    //SprüheMarkierung((int)Information.ZielNahrung, MarkierungGrößeSammler);
                    GeheZuZiel(zucker);
                    memory.ActionDone(DecisionType.SammelnZucker);
                    setActionBreak();
                }
                else
                {
                    Weitermachen();
                }
            }
            else
            {
                //traegt Nahrung
                //Weitermachen();
                GeheZuBau();
            }
        }
Example #12
0
        /// <summary>
        /// Wird einmal aufgerufen, wenn die Ameise eine Markierung des selben
        /// Volkes riecht. Einmal gerochene Markierungen werden nicht erneut
        /// gerochen.
        /// </summary>
        /// <param name="markierung">Die nächste neue Markierung.</param>
        public override void RiechtFreund(Markierung markierung)
        {
            Marker marker = Markers.Get(markierung.Information);

            try
            {
                switch (marker.markerType)
                {
                case Marker.MarkerType.HilfeAmeise:
                    //Hilfsbereitschaft, Teamfähigkeit prüfen
                    //Nahrung fallen lassen
                    //helfen

                    //wenn sie nicht schon beim angreifen ist
                    if (!greiftAn)
                    {
                        //dann über Angriff nachdenken
                        if (FuzzyInferenceSystem.Superdecision5x5x2(character.teamfaehigkeit, character.ameisenFreundeInNaehe, character.angreifen, memory.GetDecisionValue(DecisionType.AngreifenAmeise)))
                        {
                            if (marker.markerInformation == Marker.MarkerInformationType.Insekt)
                            {
                                LasseNahrungFallen();
                                trägtNahrung = false;
                                GreifeAn(marker.Insekt);
                                greiftAn    = true;
                                hilftFreund = true;
                                memory.ActionDone(DecisionType.AngreifenAmeise);
                                setActionBreak();
                            }
                            else
                            {
                                Weitermachen();
                            }
                        }
                        else
                        {
                            Weitermachen();
                        }
                    }
                    else
                    {
                        Weitermachen();
                    }
                    break;

                case Marker.MarkerType.HilfeObst:
                    //Hilfsbereitschaft, Teamfähigkeit prüfen
                    //nur wenn keine eigene Nahrung
                    //helfen
                    if (!trägtNahrung)
                    {
                        if (FuzzyInferenceSystem.Superdecision5x5x2(character.faulheit, character.energie, character.sammelnobst, memory.GetDecisionValue(DecisionType.SammelnObst)) && FuzzyInferenceSystem.Superdecision5x5x2(character.teamfaehigkeit, character.ameisenFreundeInNaehe, character.sammelnobst, memory.GetDecisionValue(DecisionType.Gruppieren)))
                        {
                            if (marker.markerInformation == Marker.MarkerInformationType.Object)
                            {
                                GeheZuZiel(marker.Objekt);
                                hilftFreund = true;
                                memory.ActionDone(DecisionType.SammelnObst);
                                memory.ActionDone(DecisionType.Gruppieren);
                                setActionBreak();
                                //SprüheMarkierung(Markers.Add(new Marker(Marker.MarkerType.Obst, marker.Objekt)), MarkierungGrößeHilfeLokal);
                            }
                            else
                            {
                                Weitermachen();
                            }
                        }
                        else
                        {
                            Weitermachen();
                        }
                    }
                    else
                    {
                        Weitermachen();
                    }
                    break;

                case Marker.MarkerType.HilfeWanze:
                    //Hilfsbereitschaft, Teamfähigkeit prüfen
                    //Anzahl Freunde prüfen
                    //Nahrung fallen lassen
                    //helfen

                    //wenn sie nicht schon beim Angreifen ist
                    if (!greiftAn)
                    {
                        //dann über Angriff nachdenken
                        if (FuzzyInferenceSystem.Superdecision5x5x2(character.teamfaehigkeit, character.ameisenFeindeInNaehe, character.angreifen, memory.GetDecisionValue(DecisionType.AngreifenWanze)))
                        {
                            if (marker.markerInformation == Marker.MarkerInformationType.Insekt)
                            {
                                LasseNahrungFallen();
                                trägtNahrung = false;
                                GreifeAn(marker.Insekt);
                                greiftAn    = true;
                                hilftFreund = true;
                                memory.ActionDone(DecisionType.AngreifenWanze);
                                setActionBreak();
                                //SprüheMarkierung(Markers.Add(new Marker(Marker.MarkerType.HilfeWanze, marker.Insekt)), MarkierungGrößeHilfeLokal);
                            }
                        }
                        else
                        {
                            Weitermachen();
                        }
                    }
                    else
                    {
                        Weitermachen();
                    }
                    break;

                case Marker.MarkerType.Obst:
                    //das gleiche wie bei siehtObst()
                    if (!trägtNahrung)
                    {
                        if (FuzzyInferenceSystem.Superdecision5x5x2(character.faulheit, character.energie, character.sammelnobst, memory.GetDecisionValue(DecisionType.SammelnObst)) && FuzzyInferenceSystem.Superdecision5x5x2(character.teamfaehigkeit, character.ameisenFreundeInNaehe, character.sammelnobst, memory.GetDecisionValue(DecisionType.Gruppieren)))
                        {
                            if (marker.markerInformation == Marker.MarkerInformationType.Object)
                            {
                                GeheZuZiel(marker.Objekt);
                                hilftFreund = true;
                                memory.ActionDone(DecisionType.SammelnObst);
                                memory.ActionDone(DecisionType.Gruppieren);
                                setActionBreak();

                                //SprüheMarkierung
                                //SprüheMarkierung(Markers.Add(new Marker(Marker.MarkerType.HilfeObst, marker.Objekt)), MarkierungGrößeHilfeLokal);
                            }
                            else
                            {
                                Weitermachen();
                            }
                        }
                        else
                        {
                            //kein Bock, Obst aufzunehmen
                            Weitermachen();
                        }
                    }
                    else
                    {
                        Weitermachen();
                    }
                    break;

                case Marker.MarkerType.Zucker:
                    //das Gleiche wie bei siehtZucker()
                    if (!trägtNahrung)
                    {
                        if (FuzzyInferenceSystem.Superdecision5x5x2(character.faulheit, character.energie, character.sammelnzucker, memory.GetDecisionValue(DecisionType.SammelnZucker)))
                        {
                            //SprüheMarkierung((int)Information.ZielNahrung, MarkierungGrößeSammler);
                            if (marker.markerInformation == Marker.MarkerInformationType.Object)
                            {
                                GeheZuZiel(marker.Objekt);
                            }
                            else
                            {
                                if (marker.markerInformation == Marker.MarkerInformationType.Richtung)
                                {
                                    DreheInRichtung(marker.richtung);
                                    GeheGeradeaus();


                                    memory.ActionDone(DecisionType.SammelnZucker);
                                    setActionBreak();

                                    //SprüheMarkierung
                                    //SprüheMarkierung(Markers.Add(new Marker(Marker.MarkerType.Zucker, marker.Objekt)), MarkierungGrößeInformation);
                                }
                                else
                                {
                                    Weitermachen();
                                }
                            }
                        }
                        else
                        {
                            Weitermachen();
                        }
                    }
                    else
                    {
                        //traegt Nahrung
                        Weitermachen();
                    }
                    break;

                default:
                    Weitermachen();
                    break;
                }
            }
            catch (NullReferenceException)
            {
                //wahrscheinlich ungültige Markierung
            }
        }