[C#] Frage Zu AntMe Code

Dieses Thema im Forum "Programmierung & Entwicklung" wurde erstellt von Flu, 8. Oktober 2009 .

Schlagworte:
  1. 8. Oktober 2009
    Frage Zu AntMe Code

    Hallo, habe ein Problem beim code von Antme der Ameisensimulation.
    habe einen ticketmanager, und eine Hauptklasse und eine Klasse Koordinatenspeicher erstellt.
    klappt auch alles so weit ganz gut, bis auf eine Sache, meine ameisen gehen zwar zum Zucker, bleiben aber einfach da stehen, statt den zucker aufzunehmen und zum bau zu gehn.
    woran liegt das?

    Hier der Code

    Hauptklasse

    Spoiler
    Code:
    using System;
    using System.Collections.Generic;
    
    //using AntMe.Deutsch;
    
    
    //Änderungen:
    //ObstaufWegzuBau
    //Objekt zu geloeschteObjekte hinzufügen
    
    
    // Füge hier hinter AntMe.Spieler einen Punkt und deinen Namen ohne Leerzeichen
    // ein! Zum Beispiel "AntMe.Spieler.WolfgangGallo".
    namespace AntMe.Spieler
    {
     // 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(
     Name = "***",
     Vorname = "***",
     Nachname = "***"
     )]
    
     // 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.
     [Typ(
     Name = "Sammler",
     GeschwindigkeitModifikator = 1,
     DrehgeschwindigkeitModifikator = -1,
     LastModifikator = 2,
     ReichweiteModifikator = 0,
     SichtweiteModifikator = 0,
     EnergieModifikator = -1,
     AngriffModifikator = -1
     )]
    
     [Typ(
     Name = "Obstameise",
     GeschwindigkeitModifikator = 1,
     DrehgeschwindigkeitModifikator = -1,
     LastModifikator = 2,
     ReichweiteModifikator = 0,
     SichtweiteModifikator = 0,
     EnergieModifikator = -1,
     AngriffModifikator = -1
     )]
    
     [Typ(
     Name = "Krieger",
     GeschwindigkeitModifikator = 1,
     DrehgeschwindigkeitModifikator = -1,
     LastModifikator = 2,
     ReichweiteModifikator = 0,
     SichtweiteModifikator = 0,
     EnergieModifikator = -1,
     AngriffModifikator = -1
     )]
    
     [Typ(
     Name = "Kundschafter",
     GeschwindigkeitModifikator = 2,
     DrehgeschwindigkeitModifikator = -1,
     LastModifikator = -1,
     ReichweiteModifikator = 0,
     SichtweiteModifikator = 2,
     EnergieModifikator = -1,
     AngriffModifikator = -1
     )]
    
     public class MeineAmeise : Ameise
     {
     private Ticket Ticket;
     private bool ObstaufWegzuBau = false;
     
    
     #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 static string BestimmeTyp(Dictionary<string, int> anzahl)
     {
     if (anzahl["Kundschafter"] < 5)
     {
     return "Kundschafter";
     }
     else if (anzahl["Sammler"] < 90)
     {
     return "Sammler";
     }
     else
     {
     return "Krieger";
     }
    
     }
    
     public static void Initialisiere()
     {
     }
    
     public MeineAmeise(Volk volk, int typIndex)
     : base(volk, typIndex)
     {
     }
    
     #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()
     {
     GeheZuBau();
     }
    
     #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)
     {
     //Ticketmanager.MeldeObjekt(zucker);
     
     Ticketmanager.MeldeObjekt(zucker);
     if (Typ == "Sammler")
     {
     GeheZuZiel(zucker);
     }
     if (Typ == "Kundschafter")
     {
     GeheGeradeaus();
     }
     }
    
     /// <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)
     {
     //Ticketmanager.MeldeObjekt(obst);
     
     Ticketmanager.MeldeObjekt(obst);
     if (Typ == "Sammler")
     {
     GeheZuZiel(obst);
     }
     if (Typ == "Kundschafter")
     {
     GeheGeradeaus();
     }
     
     }
    
     /// <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)
     {
     if (Typ == "Sammler")
     {
     Nimm(zucker);
     GeheZuBau();
     }
     if (Typ == "Kundschafter")
     {
     GeheGeradeaus();
     }
     
     
     Ticket = null;
     }
    
     /// <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();
     }
     ObstaufWegzuBau = true;
     }
    
     #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 Sieht(Markierung markierung)
     {
     }
    
     /// <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 Sieht(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 Sieht(Käfer käfer)
     {
     }
    
     /// <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(Käfer käfer)
     {
     }
    
     /// <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 (AktuelleEnergie <= 0)
     {
     Ticketmanager.MeldeMisserfolg(Ticket);
     }
     if (ObstaufWegzuBau && GetragenesObst == null)
     {
     ObstaufWegzuBau = false;
     Ticket = null;
     }
     if (Ziel == null)
     {
     if (Ticket == null)
     {
     Ticket t = Ticketmanager.GibTicket();
     if (t != null)
     {
     GeheZuZiel(t.TicketZiel);
     Ticket = t;
     }
     else
     {
     GeheGeradeaus();
     }
     }
     else
     {
     GeheZuZiel(Ticket.TicketZiel);
     }
     }
     }
    
     #endregion
    
     }
    }

    Ticketmanager
    Spoiler
    Code:
    using System;
    using System.Collections.Generic;
    using System.Text;
    //using AntMe.Deutsch;
    
    namespace AntMe.Spieler
    {
     class Ticket
     {
     private IKoordinate ticketZiel;
    
     public IKoordinate TicketZiel
     {
     get { return ticketZiel; }
     }
     public Ticket(IKoordinate ziel)
     {
     ticketZiel = ziel;
     }
     }
     class Ticketmanager
     {
     private static List<IKoordinate> gefundeneObjekte = new List<IKoordinate>();
     private static List<Ticket> tickets = new List<Ticket>();
    
     public static void MeldeObjekt(IKoordinate objekt)
     {
     if (!gefundeneObjekte.Contains(objekt) && objekt != null)
     {
     gefundeneObjekte.Add(objekt);
     if (objekt is Zucker)
     {
     Zucker zucker = objekt as Zucker;
     for (int i = 0; i < zucker.Menge / 10; i++)
     {
     tickets.Add(new Ticket(objekt));
     }
     }
     else
     {
     if (objekt is Obst)
     {
     for (int i = 0; i < 7; i++)
     {
     tickets.Add(new Ticket(objekt));
     }
     }
     }
     }
     }
    
     public static Ticket GibTicket()
     {
     foreach (Ticket t in tickets)
     {
     tickets.Remove(t);
     return t;
     }
     return null;
     }
    
     public static void MeldeMisserfolg(Ticket tic)
     {
     if (tic != null)
     {
     tickets.Add(tic);
     }
     }
     }
    }
    

    Koordinatenspeicher

    Spoiler
    Code:
    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Collections;
    
    namespace AntMe.Spieler
    {
     class KoordinatenSpeicher
     {
     private static ArrayList zuckerKoordinaten = new ArrayList();
     private static ArrayList obstKoordinaten = new ArrayList();
     private static ArrayList geloeschteKoordinaten = new ArrayList();
    
     //Nur Lesezugriff auf die Felder
     public static ArrayList ZuckerKooerdinaten
     {
     get { return zuckerKoordinaten; }
     }
    
     public static ArrayList ObstKooerdinaten
     {
     get { return obstKoordinaten; }
     }
    
     public static ArrayList GeloeschteKooerdinaten
     {
     get { return geloeschteKoordinaten; }
     }
    
     // 1. Übergebenes Objekt prüfen auf Übergabe einer Referenzvariablen
     // 2. if - Anweisungen: Überprüfung ob es sich um Zucker oder Obst handelt
     // 3. Mit Add() Koordinaten in der Liste zuckerKoordinaten bzw. obstKoordinaten speichern
     public static void KoordinateSpeicher(IKoordinate koordinate)
     {
     if (koordinate != null)
     {
     if (koordinate is Zucker)
     {
     if (!zuckerKoordinaten.Contains(koordinate) && !geloeschteKoordinaten.Contains(koordinate))
     {
     zuckerKoordinaten.Add(koordinate);
     }
     }
     if (koordinate is Obst)
     {
     if (!obstKoordinaten.Contains(koordinate) && !geloeschteKoordinaten.Contains(koordinate))
     {
     obstKoordinaten.Add(koordinate);
     }
     }
     }
     }
    
     // Objekte mit Remove() wieder löschen und in Liste der gelöschten Koordinaten speichern
     public static void KoordinateLoeschen(IKoordinate koordinate)
     {
     zuckerKoordinaten.Remove(koordinate);
     obstKoordinaten.Remove(koordinate);
     geloeschteKoordinaten.Add(koordinate);
     }
    
     public static Zucker GibZucker()
     {
     if (zuckerKoordinaten.Count > 0)
     {
     foreach (IKoordinate koordinate in zuckerKoordinaten)
     {
     return (koordinate as Zucker);
     }
     }
     return null;
     }
    
     public static Obst GibObst()
     {
     if (obstKoordinaten.Count > 0)
     {
     foreach (IKoordinate koordinate in obstKoordinaten)
     {
     return (koordinate as Obst);
     }
     }
     return null;
     }
    
     }
    }
    

    Hoffe auf schnelle Hilfe, BWs wie immer ehrensache

    Flu
     
  2. Video Script

    Videos zum Themenbereich

    * gefundene Videos auf YouTube, anhand der Überschrift.