Exemplo n.º 1
0
 public void Sprint(Spielobjekt ziel)
 {
     if (ziel != null)
     {
         if (WanzenInSichtweite == 0)
         {
             GeheZuZiel(ziel);
             int d  = getD(a, ziel);
             int _a = getA(a, ziel);
             DreheInRichtung(_a);
             GeheGeradeaus(d);
         }
     }
     else
     {
         if (ziel == bau)
         {
             Init();
             Sprint(ziel);
         }
         else
         {
             BleibStehen();
         }
     }
 }
        /// <summary>
        /// Diese Methode wird in jeder Simulationsrunde aufgerufen - ungeachtet von zusätzlichen
        /// Bedingungen. Dies eignet sich für Aktionen, die unter Bedingungen ausgeführt werden
        /// sollen, die von den anderen Methoden nicht behandelt werden.
        /// Weitere Infos unter http://wiki.antme.net/de/API1:Tick
        /// </summary>
        public override void Tick()
        {
            if (this.Reichweite - this.ZurückgelegteStrecke - 9 < this.EntfernungZuBau)
            {
                //Die Anzahl an Ameisenschritten, die die Ameise noch zurücklegen kann - 9, ist kleiner als die Entfernung zum Bau
                //Also gehen wir zum Bau, damit die Ameise nicht verhungert
                this.GeheZuBauOptimized();
            }

            if (zielOptimized != null)
            {
                int distance = Koordinate.BestimmeEntfernung(this, zielOptimized);
                if (distance < Sichtweite)
                {
                    //Das Ziel befindet sich in Sichtweite. Nun wird von GeheZuZielOptimized wieder die GeheZuZiel-Methode gewechselt.
                    GeheZuZiel(zielOptimized);
                    //Hat unsere Ameise nur noch ein Ziel und das zielOptimized wird verworfen
                    zielOptimized = null;
                }
                else
                {
                    //Das Ziel befindet sich noch nicht in Sichtweite. Erneut GeheZuZielOptimized aufrufen, damit sich die Ameise erneut auf das Ziel ausrichtet.
                    //Wenn unsere Ameise einen Apfel trägt und eine gegnerische Ameise ebenfalls an diesem Apfel zieht, kommen wir von unserem Weg ab
                    //und laufen gegen den Rand des Spielfeldes
                    GeheZuZielOptimized(zielOptimized);
                }
            }
        }
Exemplo n.º 3
0
        private void GeheZuZielOptimized(Spielobjekt spielobjekt)
        {
            int distance = Koordinate.BestimmeEntfernung(this, spielobjekt);

            //int angle = Koordinate.BestimmeRichtung(this, spielobjekt);
            DreheZuZiel(spielobjekt);
            GeheGeradeaus(distance);
        }
Exemplo n.º 4
0
        protected int BestimmeY(Spielobjekt spielobjekt)
        {
            int richtung = Koordinate.BestimmeRichtung(Speicher.bau, this);
            int distance = Koordinate.BestimmeEntfernung(Speicher.bau, this) + 32;

            float angle = ((float)richtung / 360) * ((float)Math.PI * 2);

            return((int)(Math.Sin(angle) * distance));
        }
Exemplo n.º 5
0
 /// <summary>
 /// adds a game object to the game object list. used to handle remote references.
 /// </summary>
 /// <param name="obj"></param>
 /// <returns>an integer representing the object</returns>
 public static int addTarget(Spielobjekt obj)
 {
     if (targets.ContainsKey(obj))
         return targets[obj];
     else
     {
         int newTarget = incTargets();
         targets.Add(obj, newTarget);
         return newTarget;
     }
 }
Exemplo n.º 6
0
 protected void GeheZuZielOptimized(Spielobjekt spielobjekt)
 {
     if (spielobjekt != null)
     {
         int angle    = Koordinate.BestimmeRichtung(this, spielobjekt);
         int distance = Koordinate.BestimmeEntfernung(this, spielobjekt);
         DreheInRichtung(angle);
         GeheGeradeaus(distance);
         ZielOptimized = spielobjekt;
     }
 }
Exemplo n.º 7
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);
                    }
                }
            }
        }
Exemplo n.º 8
0
 private void GeheZuBauOptimized(Spielobjekt spielobjekt)
 {
     if (bau != null)
     {
         GeheZuZielOptimized(spielobjekt);
         Denke("Nach Hause");
         ankunftsort = spielobjekt;
     }
     else
     {
         GeheZuBau();
     }
 }
Exemplo n.º 9
0
 /// <summary>
 /// adds a game object to the game object list. used to handle remote references.
 /// </summary>
 /// <param name="obj"></param>
 /// <returns>an integer representing the object</returns>
 public static int addTarget(Spielobjekt obj)
 {
     if (targets.ContainsKey(obj))
     {
         return(targets[obj]);
     }
     else
     {
         int newTarget = incTargets();
         targets.Add(obj, newTarget);
         return(newTarget);
     }
 }
        /// <summary>
        /// Alternative zur Funktion namens GeheZuZiel, mit der die Ameise optimiert zum Ziel geht, also ohne Zick-Zack-Lauf
        /// </summary>
        /// <param name="zielOptimized">Das Ziel zu dem optimiert gelaufen werden soll</param>
        private void GeheZuZielOptimized(Spielobjekt zielOptimized)
        {
            //Entfernung zwischen der Ameise und dem übergebenen Ziel
            int distance = Koordinate.BestimmeEntfernung(this, zielOptimized);
            //Winkel zwischen mir und dem Ziel
            int angle = Koordinate.BestimmeRichtung(this, zielOptimized);

            //In Richtung des übergebenen Ziels drehen
            DreheInRichtung(angle);
            //Um die soeben berechnete Entfernung geradeaus gehen, um zum übergebenen Ziel zu gehen.
            GeheGeradeaus(distance);
            //Das zielOptimized der Ameise auf das übergebene Ziel setzen.
            this.zielOptimized = zielOptimized;
        }
Exemplo n.º 11
0
        /// <summary>
        /// Diese Methode wird in jeder Simulationsrunde aufgerufen - ungeachtet von zusätzlichen
        /// Bedingungen. Dies eignet sich für Aktionen, die unter Bedingungen ausgeführt werden
        /// sollen, die von den anderen Methoden nicht behandelt werden.
        /// Weitere Infos unter http://wiki.antme.net/de/API1:Tick
        /// </summary>
        public override void Tick()
        {
            // Wenn 2 Gegner in der Nähe des Störers ist, ruft sie um Hilfe, damit die Gegner beseitigt werden und sie den Apfel wegziehen kann.
            if (Kaste == "Störer" && AktuelleLast > 0 && AnzahlFremderAmeisenInSichtweite > 2 && Hilferufe < 1)
            {
                Hilferuf.Add(this);
                Hilferufe++;
            }
            // Und wenn der Apfel weit genug weg ist, wird der Apfel wieder fallen gelassen.
            if (Kaste == "Störer" && AktuelleLast > 0 && (int)(Math.Sqrt(Math.Pow(GenaueBauKoordinaten.Item1 - HoleKoordinaten(this).Item1, 2) + Math.Pow(GenaueBauKoordinaten.Item2 - HoleKoordinaten(this).Item2, 2))) > 205)
            {
                LasseNahrungFallen();
                zielapfel = false;
                Hilferufe = 0;
            }
            // Krieger soll zu unserem Störer hingehen
            if (kriegerziel != null)
            {
                if (Koordinate.BestimmeEntfernung(this, kriegerziel) < 20 && AnzahlFremderAmeisenInSichtweite == 0)
                {
                    kriegerziel = null;
                }
            }
            // Sind Äpfel weg, werden sie auch aus der Liste entfernt
            for (int i = Äpfel.Count - 1; i >= 0; i--)
            {
                if (Äpfel.ElementAt(i).Item1.Menge == 0)
                {
                    Äpfel.Remove(Äpfel.ElementAt(i));
                }
            }

            // Positionsbestimmung von unserem Bau
            if (bau == null)
            {
                GeheZuBau();
                bau = Ziel;
                BleibStehen();
            }

            // Hat die feindliche Ameise ihre Last noch nicht abgelegt, soll sie solange verfolgt werden, bis sie es tut und in dem Moment werden ihre Koordinaten als gegnerischer Bau gespeichert
            if (ziel != null && GenaueBauKoordinaten == null)
            {
                if (ziel.AktuelleLast == 0)
                {
                    GenaueBauKoordinaten = HoleKoordinaten(ziel);
                }
                GeheZuKoordinate(HoleKoordinaten(ziel));
            }
        }
Exemplo n.º 12
0
        /// <summary>
        /// sends the current game state to the server and retrieves the command list for this ant.
        /// </summary>
        /// <param name="func">function that should be called remotely</param>
        /// <param name="obj">optional game object, e.g. sugar</param>
        private void networkCommands(string func, Spielobjekt obj = null, string objParam1 = null, string objParam2 = null)
        {
            if (obj != null)
            {
                Network.send(client, Network.state2string(func, addTarget(obj), objParam1, objParam2, this));
            }
            else
            {
                Network.send(client, Network.state2string(func, this));
            }
            string cmds = Network.receive(client);

            execCommands(cmds);
        }
Exemplo n.º 13
0
        /// <summary>
        /// Diese Methode wird in jeder Simulationsrunde aufgerufen - ungeachtet von zusätzlichen
        /// Bedingungen. Dies eignet sich für Aktionen, die unter Bedingungen ausgeführt werden
        /// sollen, die von den anderen Methoden nicht behandelt werden.
        /// Weitere Infos unter http://wiki.antme.net/de/API1:Tick
        /// </summary>
        public override void Tick()
        {
            if (Reichweite - ZurückgelegteStrecke - 20 < EntfernungZuBau)
            {
                GeheZuBau();
            }

            if (AktuelleLast > 0 && GetragenesObst == null)
            {
                SprüheMarkierung(Richtung + 180, 0);
                Denke("Wo ich herkomme gibt's Fressen!!");
            }

            aktuellesZiel = Ziel;
        }
Exemplo n.º 14
0
        /// <summary>
        /// Diese Methode wird in jeder Simulationsrunde aufgerufen - ungeachtet von zusätzlichen
        /// Bedingungen. Dies eignet sich für Aktionen, die unter Bedingungen ausgeführt werden
        /// sollen, die von den anderen Methoden nicht behandelt werden.
        /// Weitere Infos unter http://wiki.antme.net/de/API1:Tick
        /// </summary>
        public override void Tick()
        {
            //Schickt erschöpfte Ameisen zurück

            /*if (Reichweite - ZurückgelegteStrecke -20 < EntfernungZuBau)
             * {
             *  GeheZuBau();
             * }*/

            //Wenn die Ameise Last hat, dann soll sie zum Bau gehen
            if (AktuelleLast != 0)
            {
                GeheZuBauOptimized(bau);
            }

            //Schaue wie gro
            if (ankunftsort != null)
            {
                int distance = Koordinate.BestimmeEntfernung(this, ankunftsort);
                if (distance < Sichtweite / 2)
                {
                    GeheZuBau();
                    ankunftsort = null;
                }
            }

            //Findet heraus, ob der Zuckerberg noch existiert, wenn du dein Zucker schon abgeliefert hast
            if (zuckers != null && AktuelleLast == 0)
            {
                if (zuckers.Menge <= 0)
                {
                    zuckers = null;
                    BleibStehen();
                }
            }

            //Ermöglicht anderen Ameisen zu wissen, wo Zucker ist

            /*
             * if (AktuelleLast > 0)
             * {
             *  if (GetragenesObst == null)
             *  {
             *      SprüheMarkierung(Richtung + 180, 100);
             *  }
             * }
             */
        }
Exemplo n.º 15
0
        /// <summary>
        /// Diese Methode ermittelt die Koordinaten für Ameisen auf dem Spielfeld.
        /// </summary>
        /// <param name="ameise"> Ameise </param>
        /// <returns> Koordinaten als Tuple </returns>
        public Tuple <int, int> HoleKoordinaten(Basisameise ameise)
        {
            if (bau != null)
            {
                double distanz  = Koordinate.BestimmeEntfernung(ameise, bau);
                double richtung = Koordinate.BestimmeRichtung(bau, ameise);

                double winkel = (richtung / 360) * (Math.PI * 2);

                int x = (int)(Math.Cos(winkel) * distanz);
                int y = (int)(Math.Sin(winkel) * distanz);

                return(new Tuple <int, int>(x, y));
            }
            GeheZuBau();
            bau = Ziel;
            BleibStehen();
            return(HoleKoordinaten(ameise));
        }
Exemplo n.º 16
0
        /// <summary>
        /// Diese Methode wird in jeder Simulationsrunde aufgerufen - ungeachtet von zusätzlichen
        /// Bedingungen. Dies eignet sich für Aktionen, die unter Bedingungen ausgeführt werden
        /// sollen, die von den anderen Methoden nicht behandelt werden.
        /// Weitere Infos unter http://wiki.antme.net/de/API1:Tick
        /// </summary>
        public override void Tick()
        {
            if (ZielOptimized != null)
            {
                //int distance = Koordinate.BestimmeEntfernung(this, ZielOptimized);
                if (/*distance < Sichtweite*/ Koordinate.BestimmeEntfernung(this, ZielOptimized) < Sichtweite)
                {
                    GeheZuZiel(ZielOptimized);
                    ZielOptimized = null;
                }
            }

            if (Reichweite - ZurückgelegteStrecke - 20 < EntfernungZuBau)
            {
                GeheZuBauOptimized();
            }

            //if (AktuelleLast > 0 && GetragenesObst == null)
            //{
            //    SprüheMarkierung(Richtung + 180, 50);
            //}
        }
Exemplo n.º 17
0
 public new void GeheZuZiel(Spielobjekt ziel)
 {
     Ziel = ziel;
     DreheInRichtung(Koordinate.BestimmeRichtung(this, ziel));
     GeheGeradeaus();
 }
Exemplo n.º 18
0
 public int getD(Spielobjekt a, Spielobjekt b)
 {
     return(Koordinate.BestimmeEntfernung(a, b));
 }
Exemplo n.º 19
0
 public void GeheZuZiel(Spielobjekt z)
 {
     a.GeheZuZiel(z);
 }
Exemplo n.º 20
0
 private void initBau()
 {
     (this as Basisameise).GeheZuBau();
     bau = Ziel;
     BleibStehen();
 }
Exemplo n.º 21
0
        public override void Tick()
        {
            // Ziel erreicht Aktion
            if (ZielOptimized != null)
            {
                int distance = Koordinate.BestimmeEntfernung(this, ZielOptimized);
                if (distance < Sichtweite / 1.5)
                {
                    GeheZuZiel(ZielOptimized);
                    ZielOptimized = null;
                }
            }

            // Resurcen Refresher
            if (Speicher.akt_zucker != null && Speicher.akt_zucker.Menge <= 0)
            {
                Speicher.zucker_sort();
            }
            if (Speicher.zucker_counter >= 100)
            {
                Speicher.zucker_refresh();
                Speicher.zucker_counter = 0;
            }
            if (Speicher.obst_counter >= 5)
            {
                Speicher.obst_refresh();
                Speicher.obst_counter = 0;
            }
            if (Speicher.wanzen_counter >= 10)
            {
                Speicher.akt_wanze      = null;
                Speicher.wanzen_counter = 0;
            }

            // Obst tragerichtung reset
            if (Kaste == "Sammler" && GetragenesObst != null && AktuelleLast > 0)
            {
                obst_angle_reset = obst_angle_reset + 1;
                if (obst_angle_reset >= 250)
                {
                    GeheZuBauOptimized();
                    obst_angle_reset = 0;
                }
            }

            // Zuweit laufende Ameisen korigieren
            if (Kaste == "Sammler" && AktuelleLast == 10 && EntfernungZuBau < 80)
            {
                GeheZuBauOptimized();
            }

            // Zulange nichts reset // bringt nicht viel
            if ((Kaste == "Sammler" || Kaste == "ZuckerKämpfer") && ZielOptimized == null)
            {
                do_nothing_counter = do_nothing_counter + 1;
                if (do_nothing_counter >= 100)
                {
                    BleibStehen();
                    do_nothing_counter = 0;
                }
            }

            // Kampfradius
            if (Kaste == "Kämpfer" && EntfernungZuBau > 350)
            {
                GeheZuBauOptimized();
            }

            // Zuckerkämpfer beim Zucker behalten
            if (Kaste == "Zuckerkämpfer" && Koordinate.BestimmeEntfernung(this, Speicher.akt_zucker) > 50)
            {
                GeheZuZielOptimized(Speicher.akt_zucker);
            }

            // Identifier
            if (Kaste == "FSpäher" || Kaste == "Späher1" || Kaste == "Späher2" || Kaste == "Späher3" || Kaste == "Späher4")
            {
                Denke("SP");
            }
            if (Kaste == "Sammler")
            {
                Denke("S");
            }
            if (Kaste == "Kämpfer")
            {
                Denke("K");
            }
            if (Kaste == "ZuckerKämpfer")
            {
                Denke("ZK");
            }
        }
Exemplo n.º 22
0
 public int getA(Simulation.CoreAnt a, Spielobjekt b)
 {
     return(Koordinate.BestimmeRichtung(a, b));
 }
Exemplo n.º 23
0
 /// <summary>
 /// sends the current game state to the server and retrieves the command list for this ant.
 /// </summary>
 /// <param name="func">function that should be called remotely</param>
 /// <param name="obj">optional game object, e.g. sugar</param>
 private void networkCommands(string func, Spielobjekt obj = null, string objParam1 = null, string objParam2 = null)
 {
     if(obj != null)
         Network.send(client, Network.state2string(func, addTarget(obj), objParam1, objParam2, this));
     else
         Network.send(client, Network.state2string(func, this));
     string cmds = Network.receive(client);
     execCommands(cmds);
 }
Exemplo n.º 24
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 angreift oder noch Nahrung sammelt
                    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)
                            {
                                if (Ziel.GetType() == typeof(Zucker))
                                {
                                    AltesZiel = Ziel;
                                }

                                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 && !greiftAn && !hilftFreund)
                    {
                        if (FuzzyInferenceSystem.CorrelateDecisionfunctions(FuzzyInferenceSystem.Superdecision5x5x2_Double(character.faulheit, character.energie, character.sammelnobst, memory.GetDecisionValue(DecisionType.SammelnObst)), FuzzyInferenceSystem.Superdecision5x5x2_Double(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.ameisenFreundeInNaehe, character.angreifen, memory.GetDecisionValue(DecisionType.AngreifenWanze)))
                        {
                            if (marker.markerInformation == Marker.MarkerInformationType.Insekt)
                            {
                                if (Ziel.GetType() == typeof(Zucker))
                                {
                                    AltesZiel = Ziel;
                                }

                                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 && !greiftAn && !hilftFreund)
                    {
                        if (FuzzyInferenceSystem.CorrelateDecisionfunctions(FuzzyInferenceSystem.Superdecision5x5x2_Double(character.faulheit, character.energie, character.sammelnobst, memory.GetDecisionValue(DecisionType.SammelnObst)), FuzzyInferenceSystem.Superdecision5x5x2_Double(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 && !greiftAn && !hilftFreund)
                    {
                        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);
                                memory.ActionDone(DecisionType.SammelnZucker);
                                setActionBreak();
                            }
                            else
                            {
                                if (marker.markerInformation == Marker.MarkerInformationType.Richtung)
                                {
                                    if (Ziel.GetType() != typeof(Zucker))
                                    {       //wichtig, damit Ameisen, die zum Zucker gehen, nicht am Zucker vorbei gelenkt werden
                                        DreheInRichtung(marker.richtung);
                                        GeheGeradeaus();
                                        memory.ActionDone(DecisionType.SammelnZucker);
                                        setActionBreak();
                                    }
                                    else
                                    {
                                        Weitermachen();
                                    }
                                    //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
            }
        }
Exemplo n.º 25
0
 public int getA(Spielobjekt a, Spielobjekt b)
 {
     return(Koordinate.BestimmeRichtung(a, b));
 }
Exemplo n.º 26
0
 public Marker(MarkerType markerType, Spielobjekt objekt)
 {
     this.markerType        = markerType;
     this.markerInformation = MarkerInformationType.Object;
     this.Objekt            = objekt;
 }
Exemplo n.º 27
0
 public void GeheWegVon(Spielobjekt z)
 {
     a.GeheWegVon(z);
 }
Exemplo n.º 28
0
 public void DreheZuZiel(Spielobjekt z)
 {
     a.DreheZuZiel(z);
 }
Exemplo n.º 29
0
 public int getD(Simulation.CoreAnt a, Spielobjekt b)
 {
     return(Koordinate.BestimmeEntfernung(a, b));
 }