Fehler beim angreifen von Ameisen

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

    • Fehler beim angreifen von Ameisen

      Hallo zusammen,
      ich habe das Problem, dass einige Funktionen nicht mehr richtig laufen.
      Aus dem Internet habe ich mir einen Beispielcode gezogen und wollte diesen nun erweitern.
      Beim Angreifen der Ameisen aber bekomme ich einen Fehler, als ob er "ameise" nicht kennt...

      Könnt Ihr mir helfen?

      [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.Username
      {

      // 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 = "Sammlungsmeise",
      Vorname = "Don",
      Nachname = "Der"
      )]

      // 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 = "Scout",
      GeschwindigkeitModifikator = 2,
      DrehgeschwindigkeitModifikator = -1,
      LastModifikator = -1,
      ReichweiteModifikator = 0,
      SichtweiteModifikator = 2,
      EnergieModifikator = -1,
      AngriffModifikator = -1
      )]

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

      public class Ameise : Basisameise
      {

      #region Kaste

      ///
      /// Bestimmt die Kaste einer neuen Ameise.
      ///
      /// Die Anzahl der von jeder Kaste bereits vorhandenen
      /// Ameisen.
      /// Der Name der Kaste der Ameise.
      public override string BestimmeKaste(Dictionary<string, int> anzahl)
      {
      if (anzahl["Scout"] < 3)
      return "Scout";
      return "Sammler";
      }

      #endregion

      #region Fortbewegung

      ///
      /// Wird wiederholt aufgerufen, wenn der die Ameise nicht weiss wo sie
      /// hingehen soll.
      ///
      public override void Wartet()
      {
      if (Kaste == "Sammler"
      || Kaste == "Scout")
      {
      DreheUmWinkel(Zufall.Zahl(359));
      GeheGeradeaus();
      }
      }

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

      #endregion

      #region Nahrung

      ///
      /// Wird wiederholt aufgerufen, wenn die Ameise mindestens einen
      /// Zuckerhaufen sieht.
      ///
      /// Der nächstgelegene Zuckerhaufen.
      public override void Sieht(Zucker zucker)
      {
      bool treffer = false;
      foreach (ZuckerElement z in Süsses)
      if (z.Z == zucker)
      treffer = true;

      if (!treffer)
      Süsses.Add(new ZuckerElement(zucker));
      }

      ///
      /// Wird wiederholt aufgerufen, wenn die Ameise mindstens ein
      /// Obststück sieht.
      ///
      /// Das nächstgelegene Obststück.
      public override void Sieht(Obst obst)
      {

      }

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

      ///
      /// Wird einmal aufgerufen, wenn die Ameise ein Obststück als Ziel hat und
      /// bei diesem ankommt.
      ///
      /// Das Obstück.
      public override void ZielErreicht(Obst obst)
      {
      if (Kaste == "Sammler")
      {
      Nimm(obst);
      GeheZuBau();
      }
      }

      #endregion

      #region Kommunikation

      ///
      /// Wird einmal aufgerufen, wenn die Ameise eine Markierung des selben
      /// Volkes riecht. Einmal gerochene Markierungen werden nicht erneut
      /// gerochen.
      ///
      /// Die nächste neue Markierung.
      public override void RiechtFreund(Markierung markierung)
      {
      }

      ///
      /// Wird wiederholt aufgerufen, wenn die Ameise mindstens eine Ameise des
      /// selben Volkes sieht.
      ///
      /// Die nächstgelegene befreundete Ameise.
      public override void SiehtFreund(Ameise ameise)
      {
      }

      ///
      /// Wird aufgerufen, wenn die Ameise eine befreundete Ameise eines anderen Teams trifft.
      ///
      ///
      public override void SiehtVerbündeten(Ameise ameise)
      {
      }

      #endregion

      #region Kampf

      ///
      /// Wird wiederholt aufgerufen, wenn die Ameise mindestens eine Wanze
      /// sieht.
      ///
      /// Die nächstgelegene Wanze.
      public override void SiehtFeind(Wanze wanze)
      {
      }

      ///
      /// Wird wiederholt aufgerufen, wenn die Ameise mindestens eine Ameise eines
      /// anderen Volkes sieht.
      ///
      /// Die nächstgelegen feindliche Ameise.
      public override void SiehtFeind(Ameise ameise)
      {
      GreifeAn(ameise);
      }

      ///
      /// Wird wiederholt aufgerufen, wenn die Ameise von einer Wanze angegriffen
      /// wird.
      ///
      /// Die angreifende Wanze.
      public override void WirdAngegriffen(Wanze wanze)
      {
      }

      ///
      /// Wird wiederholt aufgerufen in der die Ameise von einer Ameise eines
      /// anderen Volkes Ameise angegriffen wird.
      ///
      /// Die angreifende feindliche Ameise.
      public override void WirdAngegriffen(Ameise ameise)
      {
      }

      #endregion

      #region Sonstiges

      ///
      /// Wird einmal aufgerufen, wenn die Ameise gestorben ist.
      ///
      /// Die Todesart der Ameise
      public override void IstGestorben(Todesart todesart)
      {
      Einwohnermeldeamt.Remove(this);
      }

      ///
      /// Wird unabhängig von äußeren Umständen in jeder Runde aufgerufen.
      ///
      public override void Tick()
      {
      // eigenen Bau als Ziel speichern
      if (Einwohnermeldeamt.Count == 0)
      {
      GeheZuBau();
      meinBau = (Bau)Ziel;
      }

      // sich selbst ins Einwohnermeldeamt eintragen
      if (!Einwohnermeldeamt.Contains(this))
      Einwohnermeldeamt.Add(this);



      // bestimmen welche Zuckerhaufen noch Sammler brauchen
      foreach (ZuckerElement z in Süsses)
      {
      int ArbeiterLast = 0;
      foreach (Ameise donmeise in Einwohnermeldeamt)
      if (donmeise.Kaste == "Sammler"
      && ( donmeise.Ziel == z.Z
      || donmeise.neuerJob == z.Z))
      ArbeiterLast += donmeise.MaximaleLast;
      if (ArbeiterLast < z.Z.Menge)
      z.brauchtArbeiter = true;
      else
      z.brauchtArbeiter = false;
      }





      // bestimmen welche Ameise den kürzesten Weg hat um Zucker abzubauen und ihr den Zucker als neuen Job zuweisen
      if (Süsses.Count > 0)
      {
      Zucker nächsterZucker = null;
      Obst nächstesObst = null;
      Ameise nächsteMeise = null;
      int Weg = Reichweite * 1000;
      foreach (Ameise donmeise in Einwohnermeldeamt)
      if (donmeise.Kaste == "Sammler")

      foreach (ObstElement o in Süsses)
      if (o.brauchtArbeiter
      && Koordinate.BestimmeEntfernung(donmeise, o.O) + o.vonBAUentfernt < Weg
      && Reichweite - ZurückgelegteStrecke > Koordinate.BestimmeEntfernung(donmeise, o.O) + o.vonBAUentfernt + 60
      && (donmeise.Ziel == null
      || (donmeise.Ziel is Zucker
      && donmeise.Ziel != 8|
      && Koordinate.BestimmeEntfernung(donmeise, donmeise.Ziel) + Koordinate.BestimmeEntfernung(donmeise.Ziel, meinBau) > Koordinate.BestimmeEntfernung(donmeise, o.O) + o.vonBAUentfernt + 60)))
      {
      Weg = Koordinate.BestimmeEntfernung(donmeise, o.O) + o.vonBAUentfernt;
      nächstesObst = o.O;
      nächsteMeise = donmeise;
      }
      if (nächsterZucker != null
      && nächsteMeise != null)
      nächsteMeise.neuerJob = nächsterZucker;
      }

      // neues Ziel verfolgen
      if (neuerJob != null)
      {
      GeheZuZiel(neuerJob);
      neuerJob = null;
      }
      }

      #endregion

      #region eigene Objekte

      #region AmeisenObjekte

      public Spielobjekt neuerJob = null;

      #endregion

      #region globale Objekte

      public static Bau meinBau = null;

      public static List<object> Einwohnermeldeamt = new List<object>();

      public static List<object> Süsses = new List<object>();




      #endregion

      #endregion
      }

      #region eigene Klassen

      public class ZuckerElement
      {
      public Zucker Z;
      public bool brauchtArbeiter;
      public int vonBAUentfernt;

      public ZuckerElement(Zucker z)
      {
      Z = z;
      brauchtArbeiter = true;
      vonBAUentfernt = Koordinate.BestimmeEntfernung(Z, Ameise.meinBau);
      }
      }





      public class ObstElement
      {
      public Obst O;
      public bool brauchtArbeiter;
      public int vonBAUentfernt;

      public ObstElement(Obst o)
      {
      O = o;
      brauchtArbeiter = true;
      vonBAUentfernt = Koordinate.BestimmeEntfernung(O, Ameise.meinBau);
      }
      }



      }

      #endregion
      [/cs]