Frage wegen Methoden ausführung

Hallo,

ich hab eine frage zu einer Methode in einer Klasse, sie wird ausgeführt obwohl ich sie nicht aufrufe bzw nicht übergebe das verwirrt mich ein wenig es handelt sich dabei um die Warte() methode in meiner Klasse Meine Ameise1.
Würd mich über jede Hilfe freuen euer

ltheonel

Hallo ltheonel,

so allgemein beschrieben, wird dir da kaum jemand weiterhelfen können.

Am besten du schaust dir mal den Ablauf im Debugger an.

herbivore

1. haben wir hier keine ahung was für eine kalsse das ist.
2. haben wir keine ahnung was dein programm macht
3. haben wir keine ahnung wie deine architektur aussieht
4. hast du an dieser stelle glück, das ich auch mal ants programmiert habe

die warten methode wird vom ants programm selbst aufgerufen wenn eine ameise gerade nix zu tun hat. dort werden aufgaben verteilt.

beim nächsten mal beachte bitte:
Wichtig: [Hinweis] Wie poste ich richtig?

Hallo nochmal,

ich muss mich entschuldigen... ich habe so früh am Morgen vergessen die Klasse anzuhängen - ist einfach zu früh sorry.
Also ja, es handelt sich bei der Klasse um die "Ants Klasse", in der es Aufgabe ist ein 3D Programm quasi zu Programmieren, welches auch für Anfänger sehr geeignet ist, da es sehr gut Dokumentiert ist und eine Art schnupper Kurs für Anfänger im Bereich 3D Programmierung ist.
Wer interessiert ist, hier ist ein Link zur Seite, auf der sich ausserdem auch andere Tutorials befinden: www.coding4fun.de .

Zurück zu meinem Problem: Ich weiss dass das Programm die Methode selbst aufruft, aber wieso tut sie das, die Methode wird gar nicht übergeben.
Und nun endlich meine Klasse :

using System;
using System.Collections.Generic;
using System.Text;
using AntMe;

namespace AntMe.Spieler.Duta {

	[Spieler(
		Name = "",
		Vorname = "",
		Nachname = ""
	)]

    // Das Typ-Attribut hier erlaubt das Ändern der Ameisen-Eigenschaften. Um hier Änderungen vorzunehmen muss
    // dem neuen Ameisentyp unbedingt ein Name zugewiesen und bei "BestimmeTyp" auch angegeben werden.
    // Eine genauere Beschreibung gibts in Lektion 6 des Ameisen-Tutorials
	[Typ(
		Name = "",
		GeschwindigkeitModifikator = 0,
		DrehgeschwindigkeitModifikator = 0,
		LastModifikator = 0,
		ReichweiteModifikator = 0,
		SichtweiteModifikator = 0,
		EnergieModifikator = 0,
		AngriffModifikator = 0
	)]

	public class MeineAmeise1 : Ameise {

        /// <summary>
        /// Gibt dem Spieler die Möglichkeit, eigene Variablen zu initialisieren.
        /// Wird vor jedem Spiel aufgerufen. Statische Variablen müssen hier
        /// initialisiert werden!
        /// </summary>
		public static void Initialisiere() {
		}

        /// <summary>
        /// Bestimmt den Typ einer neu zu erzeugenden Ameise.
        /// </summary>
        /// <param name="anzahl">Anzahl der vorhandenen Ameisen pro Typ</param>
        /// <returns>Name des Typs</returns>
		public static string BestimmeTyp(Dictionary<string, int> anzahl) {
			return "";
		}

        /// <summary>
        /// Der Ameise Konstruktor.
        /// </summary>
        /// <param name="volk">Das Volk zu dem die neue Ameise gehört</param>
        /// <param name="typIndex">Der Typ der neuen Ameise</param>
        public MeineAmeise1(Volk volk, int typIndex)	: base(volk, typIndex) {
		}

		/// <summary>
		/// Wird aufgerufen, wenn die Ameise nicht weiss wo sie hingehen soll.
		/// </summary>

Das ist die gemeinte Methode:

**:::

        GeheGeradeaus();  
    }){red}**

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

		/// <summary>
		/// Wird aufgerufen, wenn die Ameise einen Zuckerhaufen sieht.
		/// </summary>
		/// <param name="zucker">Zuckerhaufen</param>
		public override void Sieht(Zucker zucker) {
		}

		/// <summary>
		/// Wird aufgerufen, wenn die Ameise ein Stück Obst sieht.
		/// </summary>
		/// <param name="obst">Obst</param>
		public override void Sieht(Obst obst) {
		}

		/// <summary>
		/// Wird aufgerufen, wenn die Ameise einen Käfer sieht.
		/// </summary>
		/// <param name="käfer">Käfer</param>
		public override void Sieht(Käfer käfer) {
		}

		/// <summary>
		/// Wird aufgerufen, wenn die Ameise eine Markierung sieht.
		/// </summary>
		/// <param name="markierung">Markierung</param>
		public override void Sieht(Markierung markierung) {
		}

		/// <summary>
		/// Wird aufgerufen, wenn die Ameise von einem Käfer angegriffen wird.
		/// </summary>
		/// <param name="käfer">Käfer</param>
		public override void WirdAngegriffen(Käfer käfer) {
		}

		/// <summary>
		/// Wird aufgerufen, wenn die Ameise bei einem Zuckerhaufen ankommt.
		/// </summary>
		/// <param name="zucker">Zuckerhaufen</param>
		public override void ZielErreicht(Zucker zucker) {
		}

		/// <summary>
		/// Wird aufgerufen, wenn die Ameise bei einem Stück Obst ankommt.
		/// </summary>
		/// <param name="obst">Obst</param>
		public override void ZielErreicht(Obst obst) {
		}

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

		/// <summary>
		/// Wird in jeder Runde aufgerufen.
		/// </summary>
		public override void Tick() {
		}

	}

}

**PS: Sorry für meine schlecht Rechtschreibung, das muss ich auch noch lernen 👅 **

setz doch einen Breakpoint in die Methode "Wartet" und schau im CallStack von wo aus deine Methode aufgerufen wird
....oder ContextMenu "Find all references" bei der Methode
....oder änder die Sichtbarkeit von "public" auf "private" und schau wo der Compiler sich beschwert (gilt nur für innerhalb deiner DLL)
.....

Art schnupper Kurs für Anfänger im Bereich 3D Programmierung ist

wohl eher ki programmierung.

und es werden keine methoden "übergeben"

public override void Wartet()

sagt dir override was?

das programm arbeitet mit der basisklasse Ameise...

das sind aber alles grundlagenfargen und dieses wissen wird hier im forum vorrausgesetzt.