Ameisen laufen seltsam

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • Ameisen laufen seltsam

      Moin,

      gerade neu hier und schon 'n Problem^^°

      Ich hab mir gedacht, ich teste mal ein wenig mit AntMe! rum und komme soweit auch recht gut klar, aaaaber: Einige meiner Ameisen sind offenbar ausgemachte Deppen und ich kann mir nicht erklären wieso.
      Manchmal nehmen sie nen Apfel tragen ihm ohne Probleme zum Bau und manchmal laufen sie damit durch die Weltgeschichte spatzieren und bringen ihn a) nie zurück und verhungern b) natürlich auch noch irgendwann ohne Punkte erarbeitet zu haben.

      [cs]using System;
      using System.Collections.Generic;

      using AntMe.Deutsch;

      // Füge hier hinter AntMe.Spieler einen Punkt und deinen Namen ohne Leerzeichen
      // ein! Zum Beispiel "AntMe.Spieler.WolfgangGallo".
      namespace AntMe.Spieler.Blubb
      {

      // Das Spieler-Attribut erlaubt das Festlegen des Volk-Names und von Vor-
      // und Nachname des Spielers. Der Volk-Name muß zugewiesen werden, sonst wird
      // das Volk nicht gefunden.
      [Spieler(
      Volkname = "Idioten-Meisen",
      Vorname = "Blubb",
      Nachname = "Blubbblubb"
      )]

      // Das Typ-Attribut erlaubt das Ändern der Ameisen-Eigenschaften. Um den Typ
      // zu aktivieren muß ein Name zugewiesen und dieser Name in der Methode
      // BestimmeTyp zurückgegeben werden. Das Attribut kann kopiert und mit
      // verschiedenen Namen mehrfach verwendet werden.
      // Eine genauere Beschreibung gibts in Lektion 6 des Ameisen-Tutorials.
      [Kaste(
      Name = "Sammler",
      GeschwindigkeitModifikator = 1,
      DrehgeschwindigkeitModifikator = 0,
      LastModifikator = 2,
      ReichweiteModifikator = 0,
      SichtweiteModifikator = -1,
      EnergieModifikator = -1,
      AngriffModifikator = -1
      )]

      [Kaste(
      Name = "Krieger",
      GeschwindigkeitModifikator = 0,
      DrehgeschwindigkeitModifikator = -1,
      LastModifikator = -1,
      ReichweiteModifikator = -1,
      SichtweiteModifikator = 0,
      EnergieModifikator = 2,
      AngriffModifikator = 1
      )]

      [Kaste(
      Name = "Wächter",
      GeschwindigkeitModifikator = 0,
      DrehgeschwindigkeitModifikator = -1,
      LastModifikator = -1,
      ReichweiteModifikator = -1,
      SichtweiteModifikator = -1,
      EnergieModifikator = 2,
      AngriffModifikator = 2
      )]

      [Kaste(
      Name = "General",
      GeschwindigkeitModifikator = 0,
      DrehgeschwindigkeitModifikator = -1,
      LastModifikator = -1,
      ReichweiteModifikator = -1,
      SichtweiteModifikator = -1,
      EnergieModifikator = 2,
      AngriffModifikator = 2
      )]

      public class Idiotenmeise: Basisameise
      {

      #region Kaste

      /// <summary>
      /// Bestimmt die Kaste einer neuen Ameise.
      /// </summary>
      /// <param name="anzahl">Die Anzahl der von jeder Kaste bereits vorhandenen
      /// Ameisen.</param>
      /// <returns>Der Name der Kaste der Ameise.</returns>
      public override string BestimmeKaste(Dictionary<string, int> anzahl)
      {
      if (anzahl["General"] < 1)
      {
      return "General";
      }
      else if (anzahl["Krieger"] < 10)
      {
      return "Krieger";
      }
      else if (anzahl["Wächter"] < 10)
      {
      return "Wächter";
      }
      else
      {
      return "Sammler";
      }
      }

      #endregion

      #region Fortbewegung

      /// <summary>
      /// Wird wiederholt aufgerufen, wenn der die Ameise nicht weiss wo sie
      /// hingehen soll.
      /// </summary>
      public override void Wartet()
      {
      GeheGeradeaus();
      }

      /// <summary>
      /// Wird einmal aufgerufen, wenn die Ameise ein Drittel ihrer maximalen
      /// Reichweite überschritten hat.
      /// </summary>
      public override void WirdMüde()
      {
      }

      #endregion

      #region Nahrung

      /// <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)
      {
      int entfernung, richtung;
      entfernung = Koordinate.BestimmeEntfernung(this, zucker);
      richtung = Koordinate.BestimmeRichtung(this, zucker);
      SprüheMarkierung(richtung, entfernung);

      if (AktuelleLast == 0 && !(Ziel is Wanze))
      {
      GeheZuZiel(zucker);
      }
      }

      /// <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)
      {
      int entfernung, richtung;
      entfernung = Koordinate.BestimmeEntfernung(this, obst);
      richtung = Koordinate.BestimmeRichtung(this, obst);
      SprüheMarkierung(richtung, entfernung);

      if (AktuelleLast == 0 && !(Ziel is Wanze))
      {
      GeheZuZiel(obst);
      }
      }

      /// <summary>
      /// Wird einmal aufgerufen, wenn di e Ameise einen Zuckerhaufen als Ziel
      /// hat und bei diesem ankommt.
      /// </summary>
      /// <param name="zucker">Der Zuckerhaufen.</param>
      public override void ZielErreicht(Zucker zucker)
      {
      Nimm(zucker);
      GeheZuBau();
      }

      /// <summary>
      /// Wird einmal aufgerufen, wenn die Ameise ein Obststück als Ziel hat und
      /// bei diesem ankommt.
      /// </summary>
      /// <param name="obst">Das Obstück.</param>
      public override void ZielErreicht(Obst obst)
      {
      if (BrauchtNochTräger(obst))
      {
      Nimm(obst);
      GeheZuBau();
      }
      }

      #endregion

      #region Kommunikation

      /// <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)
      {
      if (Ziel == null)
      {
      DreheInRichtung(markierung.Information);
      GeheGeradeaus();
      }
      }

      /// <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)
      {

      }

      /// <summary>
      /// Wird aufgerufen, wenn die Ameise eine befreundete Ameise eines anderen Teams trifft.
      /// </summary>
      /// <param name="ameise"></param>
      public override void SiehtVerbündeten(Ameise ameise)
      {
      }

      #endregion

      #region Kampf

      /// <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)
      {
      int entfernung, richtung;
      entfernung = Koordinate.BestimmeEntfernung(this, wanze);
      richtung = Koordinate.BestimmeRichtung(this, wanze);
      SprüheMarkierung(richtung, entfernung);

      switch (Kaste)
      {
      case "Krieger":
      case "General":
      case "Wächter":
      if (AnzahlAmeisenDerSelbenKasteInSichtweite > 3)
      {
      GreifeAn(wanze);
      }
      else
      {
      GeheWegVon(wanze);
      }
      break;
      }
      }

      /// <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)
      {

      }

      /// <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)
      {
      if (Kaste == "Sammler")
      {
      LasseNahrungFallen();
      GeheWegVon(wanze);
      }
      else if (Kaste == "Krieger")
      {
      if (AnzahlAmeisenInSichtweite * MaximaleEnergie > wanze.AktuelleEnergie)
      {
      GreifeAn(wanze);
      }
      }
      }

      /// <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)
      {

      }

      #endregion

      #region Sonstiges

      /// <summary>
      /// Wird einmal aufgerufen, wenn die Ameise gestorben ist.
      /// </summary>
      /// <param name="todesart">Die Todesart der Ameise</param>
      public override void IstGestorben(Todesart todesart)
      {

      }

      /// <summary>
      /// Wird unabhängig von äußeren Umständen in jeder Runde aufgerufen.
      /// </summary>
      public override void Tick()
      {
      if (Kaste == "Wächter")
      {
      if (!(Ziel is Wanze))
      {
      if (EntfernungZuBau > 50)
      {
      GeheZuBau();
      }
      }
      else
      {
      if (EntfernungZuBau > 200)
      {
      GeheZuBau();
      }
      }
      }
      else if (Ziel is Bau && AktuelleLast == MaximaleLast && GetragenesObst == null)
      {
      SprüheMarkierung(Richtung + 180);
      }
      //else if (GetragenesObst != null)
      //{
      // GeheZuBau();
      //}
      }

      #endregion

      }
      }[/cs]

      Hab mich schon gefragt, obs an der Ameise mit deer Kaste General liegen könnte, wenn ja versteh ich nur trotzdem nicht woher das kommt.^^° Diese Ameise ist eigentlich auch nur enthalten, um später damit experimentieren zu können die Krieger in Gruppen hinter diesem Anführer her auf Wanzenjagd zu schicken.
    • Hey,
      ich kann's mir auch nicht ganz erklären aber eine Idee hätte ich.
      Und zwar probier mal im Tick() Bereich dein Auskommentierten Befehl was die Ameisen tun sollen wenn Sie Obst tragen aber kein Ziel mehr haben nicht als else if sonder als eigene if abfrage einzubinden. also so in etwa:

      [cs]
      if (GetragenesObst != null)
      {
      GeheZuBau();
      }
      #endregion[/cs]
    • Moin,

      danke erstmal für eure Antworten^^°
      Ich bin auch doof das nich erwähnt zu haben, also leider selbst Schuld. Der Befehl in der Tick Methode is auskommentiert, weil ich versucht habe herauszufinden, ob er der Schuldige ist - war er nicht, hätte ihn also theoretisch auch wieder aktivieren können bevor ich gepostet habe, habs nur vergessen, sorry.

      @BMeise:
      Dein Hinweis würde mir ja theoretisch plausibel vorkommen, aktuell teste ich aber ohne feindliche Ameisen^^