def _gib_richtung(self, letzter_zustand: FeldZustand, zug_nummer: int, aktuelle_punkte: int) -> Richtung:
# Dieser (sehr dumme) Algorithmus fährt immer nur nach rechts :)
# Hier sollte dein Algorithmus stehen!
# WICHTIG: Diese Funktion muss eine Richtung, zurückgeben, z.b Richtung.Unten
self.zahl = self.zahl + 1
if self.zahl>500:
return Richtung.zufall()
if letzter_zustand.ist_blockiert:
return Richtung.zufall()
if letzter_zustand.ist_blockiert:
return Richtung.Unten()
def _gib_richtung(self, letzter_zustand: FeldZustand, zug_nummer: int,
aktuelle_punkte: int) -> Richtung:
self._update_state(letzter_zustand, zug_nummer, aktuelle_punkte)
self._epsilon = self._calculate_epsilon(zug_nummer)
if letzter_zustand.ist_blockiert:
self._exploration_steps = min(self._exploration_steps, 0)
if self._exploration_steps <= 0:
if random.random() <= self._epsilon:
except_directions = None if self._exploration_steps == -1 else [
self.richtung, self.richtung.gegenteil
]
self._exploration_steps = 1 # self._start_exploration(zug_nummer)
self._richtung = Richtung.zufall(ausser=except_directions)
else:
self._exploration_steps = -1
if self._exploration_steps > 0:
self._exploration_steps -= 1
return self.richtung
else:
tensor = self._state.as_tensor(self._device)
with torch.no_grad():
prediction = self._model(tensor).flatten()
maximum = prediction.max().item()
indices = []
for i, v in enumerate(prediction):
if v == maximum:
indices.append(i)
action = random.choice(indices)
return action_to_direction(action)
def _gib_richtung(self, letzter_zustand: FeldZustand, zug_nummer: int, aktuelle_punkte: int) -> Richtung:
if self._zaehler >= self._schritte or letzter_zustand.ist_blockiert:
self._zaehler = 0
self._schritte = random.randint(5, self._max_schritte)
return Richtung.zufall(ausser=[self.richtung, self.richtung.gegenteil])
self._zaehler += 1
return self.richtung
def __init__(self, name: str = None):
if name:
self._name = name
else:
self._name = self.__class__.__name__
self._richtung = Richtung.zufall()
self._arena = None
self._x = -1
self._y = -1
def _gib_richtung(self, letzter_zustand: FeldZustand, zug_nummer: int, aktuelle_punkte: int) -> Richtung:
if letzter_zustand == FeldZustand.Besucht:
self.verschwendung += 1
if self.verschwendung >= 3:
self.aktuelle_richtung.zufall(ausser=(self.aktuelle_richtung, self.aktuelle_richtung.gegenteil))
self.count = 0
self.verschwendung = 0
return self.aktuelle_richtung
if self.count >= 30:
self.aktuelle_richtung = Richtung.zufall()
self.count = 0
else:
self.count += 1
if letzter_zustand.ist_blockiert:
self.aktuelle_richtung = Richtung.zufall(ausser=(self.aktuelle_richtung))
return self.aktuelle_richtung
def _gib_richtung(self, letzter_zustand: FeldZustand, zug_nummer: int, aktuelle_punkte: int) -> Richtung:
# laufe Anzahl Schritte in die gleiche Richtung ODER ändere frühzeitig die Richtung falls das Feld blockiert ist
if self._schritte_in_gleiche_richtung <= 0 or letzter_zustand.ist_blockiert:
# zufällige Anzahl an Schritten wählen, die der Algorithmus in eine Richtung läuft
self._schritte_in_gleiche_richtung = random.randint(5, 50)
# eine neue zufällige Richtung auswählen, die NICHT die aktuelle Richtung ist!
return Richtung.zufall(ausser=self.richtung)
# einen Schritt in die aktuelle Richtung machen
self._schritte_in_gleiche_richtung -= 1
return self.richtung
def _gib_richtung(self, letzter_zustand: FeldZustand, zug_nummer: int, aktuelle_punkte: int,) -> Richtung:
if letzter_zustand == FeldZustand.Wand or letzter_zustand == FeldZustand.Belegt and self.zeahler == 11:
self.meine_richtung = Richtung.zufall()
if letzter_zustand == FeldZustand.Belegt and self.zeahler == 11:
self.meine_richtung = Richtung.zufall(ausser=Richtung.Oben)
if letzter_zustand == FeldZustand.Besucht:
self.meine_richtung = Richtung.drehe_nach_rechts
if letzter_zustand == FeldZustand.Belegt and self.zeahler == 11:
self.meine_richtung = Richtung.zufall(ausser=Richtung.Rechts)
if letzter_zustand == FeldZustand.Belegt and FeldZustand.Wand or letzter_zustand == FeldZustand.Wand and FeldZustand.Belegt and self.zeahler == 11:
self.meine_richtung = Richtung.zufall()
if letzter_zustand == FeldZustand.Besucht and FeldZustand.Belegt or letzter_zustand == FeldZustand.Belegt and FeldZustand.Besucht:
for d in range (0, 7):
self.meine_richtung = Richtung.zufall()
if self.zeahler == 10:
for i in range(0, 5):
self.meine_richtung = Richtung.zufall()
self.zeahler = 11
return self.meine_richtung
def abbiegen_erdenken() -> Richtung:
if self.aktuelle_richtung.ist_horizontal:
if self.abstand(Richtung.Oben) > self.abstand(Richtung.Unten):
return Richtung.Oben
else:
return Richtung.Unten
elif self.aktuelle_richtung.ist_vertikal:
if self.abstand(Richtung.Links) > self.abstand(Richtung.Rechts):
return Richtung.Links
else:
return Richtung.Rechts
else:
return Richtung.zufall(ausser=self.aktuelle_richtung)
def get_direction(self, cell_state: FeldZustand, current_turn: int,
current_points: int) -> Richtung:
change_direction = self._chaos_steps <= 0 or cell_state.ist_blockiert
if self.already_visited_counter >= self._min_chaos_steps:
self.algorithm._already_visited_counter = 0
change_direction = True
if change_direction:
self._chaos_steps = random.randint(self._min_chaos_steps,
self._max_chaos_steps)
if cell_state == FeldZustand.Wand:
return self.direction.gegenteil
# TODO Improve chaos direction
return Richtung.zufall(
ausser=[self.direction, self.direction.gegenteil])
self._chaos_steps -= 1
return self.direction
def _gib_richtung(self, letzter_zustand: FeldZustand, zug_nummer: int, aktuelle_punkte: int) -> Richtung:
if self._mode == 5:
self.counter -= 1
# print("besucht mode")
if self.counter == 0:
self._mode = 0
return self.besucht_richtung
if letzter_zustand == FeldZustand.Besucht:
self.counter += 1
if self.counter == 5:
self.counter = 30
self._mode = 5
self.besucht_richtung = Richtung.zufall(ausser=[self.richtung, self.richtung.gegenteil])
else:
self.counter =0
if self._mode == 0:
#print("0")
if letzter_zustand.ist_blockiert:
self._r = (self._r + 1) % 4
elif letzter_zustand == FeldZustand.Besucht:
self._mode = 1
self._r = (self._r + 2) % 4
elif self._mode == 2:
#print("2")
if letzter_zustand == FeldZustand.Besucht or letzter_zustand.ist_blockiert:
self._mode = 1
self._r = (self._r + 2) % 4
elif self._mode == 1:
#print("1")
self._r = (self._r + 3) % 4
self._mode = 2
return self._zirkel[self._r]
def __init__(self):
super().__init__()
self.aktuelle_richtung = Richtung.zufall()
self.komisch = 0
self.verbleibend = 0
def __init__(self):
super().__init__()
self.aktuelle_richtung = Richtung.zufall()
self.count = 0
self.verschwendung = 0
def _gib_richtung(self, letzter_zustand: FeldZustand, zug_nummer: int, aktuelle_punkte: int) -> Richtung:
# gehe bei jedem Zug in eine zufällige Richtung
return Richtung.zufall(ausser=[self.richtung.gegenteil])
def _gib_richtung(self, letzter_zustand: FeldZustand, zug_nummer: int,
aktuelle_punkte: int) -> Richtung:
if self.blau_gedreht > 4:
if not self.phase_rechts:
if letzter_zustand != FeldZustand.Frei:
return Richtung.zufall(
ausser=self.meine_richtung.gegenteil)
else:
return self.meine_richtung
if self.liste_verschiebung_startpunkt[0] < 0:
self.meine_richtung = Richtung.Rechts
elif self.liste_verschiebung_startpunkt[0] > 0:
self.meine_richtung = Richtung.Links
else:
if self.liste_verschiebung_startpunkt[1] < 0:
self.meine_richtung = Richtung.Unten
elif self.liste_verschiebung_startpunkt[1] > 0:
self.meine_richtung = Richtung.Oben
else:
self.liste_zuege = self.liste_zuege[::-1]
self.zustand = 3
self.blau_gedreht = 0
elif self.zustand == 3:
self.meine_richtung = self.liste_zuege[self.stelle_zurueck_zuege]
self.stelle_zurueck_zuege += 1
if self.stelle_zurueck_zuege == len(self.liste_zuege):
self.phase_rechts = False
self.zustand = 0
self.blau_gedreht = 0
self.liste_verschiebung_startpunkt = [0, 0]
self.nach_start_rechteck = False
self.liste_zuege = [liste_andersrum[self.meine_richtung]]
self.stelle_zurueck_zuege = 0
elif self.zustand == 1:
self.richtung_eins_drehen()
self.zustand = 2
elif self.zustand == 2:
self.richtung_zwei_drehen()
self.zustand = 0
else:
if letzter_zustand == FeldZustand.Belegt or letzter_zustand == FeldZustand.Wand:
if len(self.liste_zuege) > 0:
self.richtung_eins_drehen()
self.liste_zuege.pop(-1)
elif letzter_zustand == FeldZustand.Besucht:
self.verschiebung_verrechnen()
self.liste_zuege.append(liste_andersrum[self.meine_richtung])
self.nach_start_rechteck = True
self.zustand = 1
self.richtung_eins_drehen()
self.blau_gedreht += 1
else:
self.blau_gedreht = 0
if self.nach_start_rechteck:
self.verschiebung_verrechnen()
else:
self.liste_zuege.append(liste_andersrum[self.meine_richtung])
return self.meine_richtung
def moveAround(self):
self.direction = Richtung.zufall(ausser=[self.richtung, self.richtung.gegenteil])
self.straightMoves = 1
def update_random(self, letzter_zustand: FeldZustand, zug_nummer: int,
aktuelle_punkte: int) -> Richtung:
if self.collided():
return Richtung.zufall(ausser=self.richtung), self.update_random
return self.richtung, self.update_random