Hallo, ich würde gern zur Wohnzimmerdekoration eine LED Matrix aus 32 x
32 LED bauen, auf der selbständig ein Snake Spiel abläuft bauen. Ich
stelle mir das so vor, das willkürlich ein Punkt, die Maus, in der
Matrix gesetzt wird und diese dann von der Schlange selbständig
gefressen wird. Die Schlange muss dabei nicht wachsen, soll ja ne
Endlosschleife sein.
Das ganze auf nem AVR. Wie hoch schätzt ihr den Aufwand ein? Den uC
ansich beherrsche ich, C kann ich auch mittelmäßig. Aber hier scheiterts
eher an der gedanklichen Umsetzung, womit man wie anfängt. Die Matrix an
sich stellt kein Problem dar.
Ingo
Der größte Aufwand wird wohl das Löten sein. Immerhin 1024 LEDs. Oder
benutzt du vorgefertigte Module?
Das Programm an sich wird schon nicht so schwer werden :)
Niemand sagt das man die LED auf einmal löten muss :). Würde die Montage
auf mehrer Arbeitsschritte ( immer mal ne Stunde nach der Arbeit )
aufteilen...
Natürlich nicht an einem Stück, aber machen musst du es ja irgendwann ;)
Ich würde, ganz grob, erstmal folgende Dinge realisieren (software):
- Die Matrix ansteuern können, also beliebige LEDs ein und ausschalten
können
- Zufallszahlen erzugen, muss ja kein echter Zufall sein.
http://de.wikipedia.org/wiki/Linear_r%C3%BCckgekoppeltes_Schieberegister
- eine Wegfindungsroutine für die Schlange überlegen.
Zufallstahlen sowie die Matrix sind nicht das Problem. Das Problem
stellt die Wegsuchroutine dar, hier würde ich systematisch erst an die
X-Koordinaten und dann die y-Koordinaten fahre , spezielle Sachen wie
durch wände gehen und auf der anderen Seite rauskommen müssen es erstmal
nicht sein. Aber die Schlange muss ja auch wenden können bzw. darf sich
selber nich berühren, hierfür muss dann ein Umweg gefunden werden. Das
stellt für mich noch ein Problem dar.
Das schwierigste dürfte die KI sein, also dass die Schlange einen Weg
zur Maus findet, ohne sich dabei selber zu berühren.
Der Rest ist eigentlich recht einfach. Wenn die Schlange eine feste
Länge hat, würd ich deren einzelne Glieder in einer Liste anordnen.
Jeder Listeneintrag enthält die Koordinaten dieses Glieds. Der erste
Listeneintrag ist der Kopf, der letzte die Schwanzspitze.
Außerdem hast Du ein Bitfeld, das die Werte der LED-Matrix enthält. 1 =
LED an, 0 = LED aus. Mit jedem Zeitschritt (z.B. eine Sekunde, durch
einen Timer ausgelöst) bewegt sich die Schlange einen Schritt. Dazu
fragst Du die KI, in welche Richtung (oben, unten, rechts, links) sie
sich bewegen soll.
In die Schlangenglieder-Liste fügst Du an den Anfang einen neuen Eintrag
ein mit den Koordinaten des vorherigen Kopfes + die Bewegung in die
Richtung. Den letzten Eintrag (die Schwanzspitze) löscht Du. Danach
berechnest Du aus der Liste und der Koordinate der Maus das neue
Bitfeld. Dieses Bitfeld wird laufend auf die LED-Matrix ausgegeben.
Ja so ähnlich habe ich mir das auch gedacht. Die KI müsste dann vor
Ausgabe der neuen Richtung prüfen, ob sich der nächste Schritt zu
Problemen führt. Das scheint ganz schön heftig zu sein, da ja Ecken und
Kurven mit berücksichtigt werden müssen. Wenn man sich da richtig
reindenkt is das schon n ganz schöner Brocken!
Ingo
Fabian O. schrieb:> Der Rest ist eigentlich recht einfach. Wenn die Schlange eine feste> Länge hat, würd ich deren einzelne Glieder in einer Liste anordnen.> Jeder Listeneintrag enthält die Koordinaten dieses Glieds. Der erste> Listeneintrag ist der Kopf, der letzte die Schwanzspitze.
Snake geht sogar noch einfacher: Du hast eine Matrix mit 32x32 Zahlen.
In das Feld, wo der Kopf ist, wird die aktuelle Länge der Schlange
geschrieben. In jedem Schritt wird jedes Feld der Matrix um 1
dekrementiert. Felder mit Wert grösser 0 sind Schlangenelemente, solche
mit Wert kleiner gleich 0 sind leere Felder.
mr.chip schrieb:> Snake geht sogar noch einfacher: Du hast eine Matrix mit 32x32 Zahlen.> In das Feld, wo der Kopf ist, wird die aktuelle Länge der Schlange> geschrieben. In jedem Schritt wird jedes Feld der Matrix um 1> dekrementiert. Felder mit Wert grösser 0 sind Schlangenelemente, solche> mit Wert kleiner gleich 0 sind leere Felder.
Das braucht aber ziemlich viel Speicher. Eigentlich reicht es doch die
Koordinaten des Kopfes zu wissen und von da aus die Lage der anderen
Elemente. So braucht man für jedes weitere Element nur 2 Bit.
Eumel schrieb:> Das braucht aber ziemlich viel Speicher. Eigentlich reicht es doch die> Koordinaten des Kopfes zu wissen und von da aus die Lage der anderen> Elemente. So braucht man für jedes weitere Element nur 2 Bit.
Ich hab nicht gesagt, es sei effizient ;-) Aber einfacher lässt sich die
Verwaltung der Schlange an sich wohl wirklich nicht beschreiben.
mr.chip schrieb:> Ich hab nicht gesagt, es sei effizient ;-) Aber einfacher lässt sich die> Verwaltung der Schlange an sich wohl wirklich nicht beschreiben.
Stimmt natürlich. Effizienz ist ja auch kein fester Begriff. Wenn der
Speicher da ist und für nichts anderes gebraucht wird, wieso nicht?
mr.chip schrieb:> Snake geht sogar noch einfacher: Du hast eine Matrix mit 32x32 Zahlen.> In das Feld, wo der Kopf ist, wird die aktuelle Länge der Schlange> geschrieben. In jedem Schritt wird jedes Feld der Matrix um 1> dekrementiert. Felder mit Wert grösser 0 sind Schlangenelemente, solche> mit Wert kleiner gleich 0 sind leere Felder.
Stimmt, die Lösung ist eleganter. Die Matrix dürfte auch die
KI-Berechnung vereinfachen und man kann sie direkt für die LED-Ausgabe
verwenden. Man muss halt mehr als 1 KB RAM zur Verfügung haben.
Man könnte sich zusätzlich noch die Koordinaten von Kopf und
Schwanzspitze extra speichern, um nicht immer das ganze Feld danach
durchsuchen zu müssen.
Fabian O. schrieb:> Man könnte sich zusätzlich noch die Koordinaten von Kopf und> Schwanzspitze extra speichern, um nicht immer das ganze Feld danach> durchsuchen zu müssen.
Man muss da nichts dursuchen.
Zum Thema KI
Ich würds nicht zu kompliziert machen.
Die Schlange fährt solange in immer dieselbe Richtung, solange in diese
Richtung frei ist. Ist das nächste Feld in Fahrtrichtung nicht frei,
wird festgestellt, wieviele Möglichkeiten es gibt (1 oder 2) und dann
wir gewürfelt, welche der beiden Richtungen genommen wird. Gibt es
keinen Weg, dann macht es FLush, die Schlange wird entfernt und startet
an einer anderen zufälligen Stelle neu.
D.h. die Schlange durchläuft mehr oder weniger zufällig das Lbyrinth.
Wenn sie auf eine Maus stösst, dann ist das reiner Zufall und nicht
mehr.
Karl Heinz Buchegger schrieb:> D.h. die Schlange durchläuft mehr oder weniger zufällig das Lbyrinth.> Wenn sie auf eine Maus stösst, dann ist das reiner Zufall und nicht> mehr.
Sie kann ja trotzdem in die richtige Richtung abbiegen, sofern frei ist.
Also ungefähr so:
1
enum{
2
RECHTS=0,
3
LINKS,
4
HOCH,
5
RUNTER,
6
};
7
8
diff_x=maus.x-schlange.x;
9
diff_y=maus.y-schlange.y;
10
11
// Bevorzugte Richtung festlegen
12
if(diff_x>0){
13
richtung=RECHTS;
14
}elseif(diff_x<0){
15
richtung=LINKS;
16
}elseif(diff_y>0){
17
richtung=HOCH;
18
}else{
19
richtung=RUNTER;
20
}
21
22
// Freie Richtung suchen
23
for(i=0;i<4;i++){
24
if(feld_frei(richtung)){
25
returnrichtung;
26
}
27
// Naechste Richtung probieren
28
if(richtung==3){
29
richtung=0;
30
}else{
31
richtung++;
32
}
33
}
34
35
// Keine Richtung mehr frei => Boom
36
returnrichtung;
Kann man natürlich noch intelligenter machen. Also z.B. falls die
bevorzugte x-Richtung nicht geht, zuerst die richtige y-Richtung
probieren. Oder wenn sie sich bereits in die richtige y-Richtung bewegt,
nicht in die x-Richtung wechseln. Oder die Alternativrichtungen in
zufälliger Reihenfolge probieren ...
Aber grundsätzlich wäre es sicher das einfachste Ansatz, nicht den
Anspruch zu haben, dass die Schlange garantiert den Weg findet, sondern
sie auch gelegentlich mal kollidieren zu lassen. Kann man ja dann mit
einer hübschen Explosionsanimation begleiten. :)
Also gehe ich recht in der Annahme, dass ein Mega644 @ 16MHZ der Aufgabe
gewachsen ist!? Dann würde ich erstmal die Hardware aufbauen bzw.
Schaltung und Layout machen.
Mit der Idee einer "dummen" Schlange könnte ich mich auch anfreunden,
ihr etwas mehr Hirn kann man ja nachträglich noch einbauen.
Ingo
Ingo schrieb:> Also gehe ich recht in der Annahme, dass ein Mega644 @ 16MHZ der Aufgabe> gewachsen ist!?
Er langweilt sich zu Tode.
Einzig das Multiplexen der LED könnte interessant werden. Mit einem 1:32
Multiplex wirst du nicht weit kommen. Höher als 1:10 ist schon
grenzwertig.
Naja, 32 ist schon krass stimmt, aber mit weniger kann ich auch leben.
Ma gucken was das Layout sagt bzw wie groß es wird. Aber es werden
dennoch mehr als 10 Zeilen und Spalten.
Mal gucken wie ich das am besten hinkriege
Ingo schrieb:> Naja, 32 ist schon krass stimmt, aber mit weniger kann ich auch leben.
Musst du ja nicht.
Man kann ja auch 4 Stück 8*32 Matrizen gleichzeitig multiplexen. Wenn
die 'zufälligerweise' so angeordnet sind, dass die Einzelmatrizen genau
übereinander stehen und man nicht sieht in welcher Zeile die eine Matrix
aufhört und die andere anfängt, ist das ja nicht deine Schuld :-)
Ein weiteres Problem sind deine LED: Du kannst den Strom nicht beliebig
durch die LED erhöhen, weil du die verminderte Helligkeit durch die hohe
Muliplexrate 1:32 ausgleichen musst.
Alternativ zum Multiplexen kannst du auch einige Schieberegister wie
74HCT595 verwenden.
http://www.mikrocontroller.net/articles/AVR-Tutorial:_Schieberegister
Rechne mal die Kosten dafür durch. Beim Multiplexen brauchst du relativ
starke und viele MOSFETs, da läppert sich ganz schön was zusammen.
Ganz grob abschätzt würde ich sagen, dass es sich von den Kosten nicht
viel gibt.
Die Lösung hat auch den Vorteil, dass du es in einzelne Module von
jeweils 8 LEDs unterteilen und diese jeweils einzeln testen(!) kannst.
Falls die Software mal hängen bleibt oder beim debuggen was schiefgeht,
brennt die hier auch nicht eine komplette Reihe durch sondern es wird
höchstens mal kurz was falsches angezeigt. Die Ansteuerung erfolgt
bequem per SPI.
Das einzige, worauf du achten musst ist die Taktflanke. Die sollte
möglichst steil sein, damit es richtig funktioniert. Hier ein paar
Buffer vorsehen und den Takt von hinten anlegen. Dadurch machst du dir
Ausbreitungsgeschwindigkeit des Stroms im Kabel zu nutze.
Gruß
Also, die Platine ist fertig, die Matrix ist allerdings eine gekaufte
mit 16x16 LEDs (rot/Grün).
Die Daten werden über SPI an die Matrix geschickt, um den Rest kümmert
sich die Matrix selber. Ma schauen wie es sich entwickelt, werde die
Woche mal anfangen zu programmieren. Ich find die Idee mit dem Kopf, der
die Länge enthält ganz gut. Mal gucken wie ich es umgesetzt kriege...
Also wenn sich die 16x16 Matrix über SPI ansteuern läßt, kannst du die
doch ganz einfach auf 32X32 erweitern indem du einfach 4 Module nimmst.
SPI ist ja multi-slave-fähig, sodaß du eigendlich nur noch 4(3) IO-Pins
für den Chip-Select brauchst.
Ingo schrieb:> Also, die Platine ist fertig, die Matrix ist allerdings eine gekaufte> mit 16x16 LEDs (rot/Grün).
Wie groß ist denn der ganze Aufbau? Ich hätte Interesse an etwas
ähnlichem - aber in "groß". Also nicht einzelne LEDs, sondern eher
"Felder" mit einer Kantenlänge von 5+ cm. Damit wäre das Ganze dann 1,6
m auf 1,6 m und ein echter Hingucker ;).
Also. Die 32 x 32 ist doch etwas zu pixelig. Ich wuerd eher einen Satz
von 8x8 Displays wie angehaengt, zB als 64x64 oder 128x128 verwenden. So
ein 8x8 Basisbaustein ist 60mm im quadrat, dh bei 64x64 waere man bei
48cm im quadrat und bei 128x128 waere man bei 96cm im quadrat. So ein
Baustein kostet 2.80 Euro bei Schukat, ab 50 stueck.
So, ich hab heute mal n bissel gespielt. Ich habe die Matrix so
programmiert, dass alle Felder die !0 sind decrementiert werden. Die
Matrix besteht aus einem Array aus 256 Chars.
Testweise gebe ich jeder Zelle einen Wert, sodass in Zelle5 eine 5 usw
steht. Damit leuchtet zu Anfang alles und nach dem decrement
verschwindet die Led (0,0), danach die (1,0). So wie es soll... Somit
ist die Anzeige erledigt. Ich brauche nun noch eine KI die die Schlange
bzw. Matrix bediehnt. Wenn ich z.B. die Schlange auf eine Wand zulaufen
lasse, soll diese der Wand ausweichen. Aber irgendwie muss sie sich ja
wieder von der Wand lösen (mal vorausgesetzt sie sucht nicht nach der
Maus), ansonsten schleicht sie ja nur an der Wand rum. Ich bin für jede
Idee dankbar, noch bin ich in der Findungsphase!
Ingo schrieb:> PUSH!
Denk dir halt was aus.
Da es sowieso ein wenig fad ist, wenn die Schlange bei einem
Deko-Demo-Stück die Maus immer auf schnellstem Weg findet, würde ich sie
über Zufallszahlen steuern.
Mit einer gewissen Wahrscheinlichkeit biegt die Schlange nach jedem
Schritt entweder nach links oder nach rechts ab, wenn der Weg dort frei
ist. Fährt sie entlang einer Wand, dann kann sie natürlich nicht in
diese Richtung abbiegen. Aber eben in die andere, wenn dort freier Raum
ist.
Willst du allerdings, dass die Schlange die Maus auf schnellstem Weg
findet, unter Berücksichtigung von 'in der Gegend rumstehenden Mauern',
die ihr den Weg versperren, dann geht ein einfacher Algorithmus, den man
früher beim zellenbasierten Routen von Leiterplatten benutzt hat.
Und das geht so.
Ausgehend von der Position der Schlange, markiert man alle freien Felder
rund um diese Position mit 1 und trägt diese Position in eine Liste ein.
Genauer gesagt gibt es 2 Listen. Eine von der Positionen genommen werden
und eine auf die Positionen gespeichert werden. Nach jedem Durchgang
werden die gespeichert Position der 2-ten Liste zu den 'aktiven'
POsitionen der 1-ten Liste.
Ein Durchgang besteht darin, dass man alle Positionen nacheinander von
der ersten Liste holt und alle freien Felder rund um diese Position mit
einer aufsteigenden Zahl markiert, wobei es genügt, dass die Zahl immer
von 1 bis 4 durchzählt. Jede so gefundene 'freie Position' wandert auf
die 2-te Liste (und wenn da natürlich die Maus dabei ist, dann hat man
sie gefunden und der Algorithmus tritt in die 2-te Phase ein, in der die
Markierungen am Spielfeld ausgewertet werden um den Weg zu finden.
Anschaulich passiert folgendes.
Angenommen das wäre das Spielfeld mit einer Schlange S, einer Maus M und
ein paar Mauern *
1
01234567890123
2
+--------------+
3
0| M |
4
1| ***** ** |
5
2| ** |
6
3| S ****** |
7
+--------------+
dann kommt als erstes die Position der Schlange (2/3) auf die aktive
Liste
Die aktive Liste wird abgearbeitet und alle Nachbarn die frei sind, mit
1 markiert.
1
01234567890123
2
+--------------+
3
0| M |
4
1| ***** ** |
5
2| 1 ** |
6
3| 1S1 ****** |
7
+--------------+
alle diese Positionen sind in die 2.te Liste eingetragen worden, die
jetzt also 3 Positionen umfasst.
Die Listen tauschen die Plätze, in der aktiven Liste sind daher jetzt 3
Positionen, die abzuarbeiten sind und deren freie Nachbarn diesmal mit 2
zu markieren sind.
1
01234567890123
2
+--------------+
3
0| M |
4
1| 2***** ** |
5
2| 212 ** |
6
3|21S12 ****** |
7
+--------------+
Wieder sind alle derartige Nachbarn in der 2.ten Liste gesammelt worden,
die Listen tauschen die Plätze und die aktive Liste wird abgearbeitet.
Markiert wird diesmal mit 3
1
01234567890123
2
+--------------+
3
0| 3 M |
4
1| 32***** ** |
5
2|32123 ** |
6
3|21S123 ****** |
7
+--------------+
Nächster Durchgang, markiert mit 4
1
01234567890123
2
+--------------+
3
0| 434 M |
4
1|432***** ** |
5
2|321234** |
6
3|21S1234****** |
7
+--------------+
Nächster Durchgang, markiert mit 1 (der Nachfolger von 4 ist 1)
1
01234567890123
2
+--------------+
3
0|14341 M |
4
1|432***** ** |
5
2|321234** |
6
3|21S1234****** |
7
+--------------+
usw.
1
01234567890123
2
+--------------+
3
0|143412 M |
4
1|432***** ** |
5
2|321234** |
6
3|21S1234****** |
7
+--------------+
usw
1
01234567890123
2
+--------------+
3
0|1434123 M |
4
1|432***** ** |
5
2|321234** |
6
3|21S1234****** |
7
+--------------+
1
01234567890123
2
+--------------+
3
0|14341234 M |
4
1|432***** ** |
5
2|321234** |
6
3|21S1234****** |
7
+--------------+
1
01234567890123
2
+--------------+
3
0|143412341 M |
4
1|432***** ** |
5
2|321234** |
6
3|21S1234****** |
7
+--------------+
1
01234567890123
2
+--------------+
3
0|1434123412 M |
4
1|432*****2 ** |
5
2|321234** |
6
3|21S1234****** |
7
+--------------+
1
01234567890123
2
+--------------+
3
0|14341234123 M |
4
1|432*****23 ** |
5
2|321234**3 |
6
3|21S1234****** |
7
+--------------+
1
01234567890123
2
+--------------+
3
0|143412341234M |
4
1|432*****234** |
5
2|321234**34 |
6
3|21S1234****** |
7
+--------------+
usw.
Hoppla. Eine der Markierungen trifft die Maus!
Was ist da passiert?
Die Markierungen haben sich wie Wellen ausgehend von der Position der
Schlange ausgebreitet und füllen alle Winkel auf.
Was bringt mir das jetzt?
Ganz einfach. Die Markierungen zeigen mir jetzt den Weg, und zwar den
kürzesten von der Maus zurück zur Schlange.
Auf die Maus bin ich mit einer Markierung von 1 gestossen. Also such ich
die Umgebung der Maus nach einer 4 ab. (weil 4 der Vorgänger von 1 ist)
1
01234567890123
2
+--------------+
3
0|14341234123#M |
4
1|432*****234** |
5
2|321234**34 |
6
3|21S1234****** |
7
+--------------+
Der Vorgänger von 4 ist 3
1
01234567890123
2
+--------------+
3
0|1434123412##M |
4
1|432*****234** |
5
2|321234**34 |
6
3|21S1234****** |
7
+--------------+
dessen Vorgänger ist 2
1
01234567890123
2
+--------------+
3
0|143412341###M |
4
1|432*****234** |
5
2|321234**34 |
6
3|21S1234****** |
7
+--------------+
1
1
01234567890123
2
+--------------+
3
0|14341234####M |
4
1|432*****234** |
5
2|321234**34 |
6
3|21S1234****** |
7
+--------------+
und der Vorgänger von 1 ist wieder die 4
1
01234567890123
2
+--------------+
3
0|1434123#####M |
4
1|432*****234** |
5
2|321234**34 |
6
3|21S1234****** |
7
+--------------+
usw.
1
01234567890123
2
+--------------+
3
0|143412######M |
4
1|432*****234** |
5
2|321234**34 |
6
3|21S1234****** |
7
+--------------+
usw.
1
01234567890123
2
+--------------+
3
0|14341#######M |
4
1|432*****234** |
5
2|321234**34 |
6
3|21S1234****** |
7
+--------------+
usw.
1
01234567890123
2
+--------------+
3
0|14##########M |
4
1|43#*****234** |
5
2|32#234**34 |
6
3|21S1234****** |
7
+--------------+
Damit steht der Weg, die restlichen Markierung mal weggenommen
1
01234567890123
2
+--------------+
3
0| ##########M |
4
1| #***** ** |
5
2| # ** |
6
3| S ****** |
7
+--------------+
Das ist der Weg, den die Schlange fahren muss, um zur Maus zu kommen.
Danke Karl Heinz, wieder weit übers Ziel hinaus geschossen. Aber danke.
Der kriecht meine Schlange im Moment noch durch Wände, aber das kommt
morgen. Zur zeit ändert frühestens alle vier Schritte den Weg, was sehr
natürlich wirkt. Ich hatte deres Anfang so das die Schlamge jeden
Schritt willkürlich wählt, aber das sieht Kacke aus, die Schlange rollt
sich mehr von a nach b. Morgen bringe ich ihr noch bei nicht durch Wände
zu spazieren und ich werd mal n paar Mäuse füttern :)
Evtl baue ich noch eine Funktion ein, dass wenn die Schlange die Maus
nicht in Zeit x gefunden sie etwas mehr Intelligenz bekommt :)
Was ich noch suche bzw auch noch nicht habe, ist ein Tool, was mir quasi
ein Hex Array mit 256 Zellen produziert Indias ich am PC per Maus was
rein malen kann, und das Bild dann in den Flash einfügen kann, sozusagen
einen PC-Editor für die Matrix. Das wird es aber so bestimmt nicht geben
vermute ich mal.
Interessante Sache, dieses Snake Deko.
Wenn die Schalnge an eine Wand läuft, ist sie dann game over? Oder
willst du sie nicht game over gehen lassen?
Sind die Wände bei dir fest gesetzt, oder setzt du die zufällig?
Ist die maus und Schlangenposition auch zufällig?
Was passiert, wenn Maus und Schlange z.B. direkt nebeneinander (Als
näher als die schlange lang ist z.b) erscheint?
Wenn man oben die Methode mit dem kürzesten Weg nimmt, könnte man da
auch noch eine Zufallskomponente einbauen? z.B. eine Wahrscheinlichkeit
von 20% dass die Schlange vom Weg abkommt und nocht den kürzesten nimmt?
Ingo schrieb:> Danke Karl Heinz, wieder weit übers Ziel hinaus geschossen. Aber danke.> Der kriecht meine Schlange im Moment noch durch Wände, aber das kommt> morgen. Zur zeit ändert frühestens alle vier Schritte den Weg, was sehr> natürlich wirkt. Ich hatte deres Anfang so das die Schlamge jeden> Schritt willkürlich wählt, aber das sieht Kacke aus,
Zufallszahl von 0 bis 10
Bei einer 4 ändert sie die Richtung nach links. bei einer 5 ändert sie
die Richtung nach rechts. In allen anderen Fällen fährt sie in die
gleiche Richtung weiter. Oder eben bei dir:
erst mal wird mit einer Zufallszahl bestimmt, ob überhaupt ein
Richtungswechsel erfolgen soll (Zufallszahl zwischen 0 und 10, und nur
bei einer einzigen oder zweien davon geht es weiter in den Modus "so das
die Schlamge jeden Schritt willkürlich wählt"
D.h. bei jedem Schritt besteht nur eine 10% Chance, dass die Schlange
die Richtung wechselt. Wenn dir das immer noch zu viel ist, dann eben:
Zufallszahl von 0 bis 20 und nur bei einer einzigen davon wird die
Richtung gewechselt.
Ingo schrieb:> Was ich noch suche bzw auch noch nicht habe, ist ein Tool, was mir quasi> ein Hex Array mit 256 Zellen produziert Indias ich am PC per Maus was> rein malen kann, und das Bild dann in den Flash einfügen kann, sozusagen> einen PC-Editor für die Matrix. Das wird es aber so bestimmt nicht geben> vermute ich mal.
den gibt es so ganz sicher nicht.
Was ich tun würde:
Ich würde mir am PC ein Tool schreiben, welches eine ASCII Zeichnung der
Situation in einer Datei
1
+----------------+
2
| |
3
| |
4
| S |
5
| ********** |
6
| * |
7
| * |
8
| |
9
| ***********|
10
| * |
11
| * |
12
| * |
13
| * *M* |
14
| * * ** |
15
|****** * |
16
| ***** |
17
| |
18
+----------------+
einliest, in die interne Struktur umsetzt und das dann als File so
ausdumpt, dass man es im AVR-Programm mit einem
1
....blablabla
2
uint8_tmatrix[256]={
3
#include"matrixdata.inc"
4
};
5
....
6
blablabal
benutzen kann. matrixdata.inc ist dabei die Datei, die dieses Hilfstool
aus der 'benutzerfreundlicheren' ASCII-Text Version der 'Szenerie'
generiert.
Also im Moment plaziere ich die Schlange willkürlich in der Matrix.
Wände in dem Sinne sind die aussenkanten der Matrix. Hindernisse gibt es
nicht. Die Maus will ich auch zufällig plazieren, jedoch nich in den
Schlangenkörper!
Ingo schrieb:> Also im Moment plaziere ich die Schlange willkürlich in der Matrix.> Wände in dem Sinne sind die aussenkanten der Matrix. Hindernisse gibt es> nicht. Die Maus will ich auch zufällig plazieren, jedoch nich in den> Schlangenkörper!
Du willst sie auch nicht in Mauern platzieren.
Wenn du Schlange die Maus findet, wird eine neue POsition für die Maus
gesucht. Solange 2 Zufallszahlen bestimmen, bis die so festgelegte
Koordinate x/y eine freie Position angibt (und meinetwegen eine gewisse
Distanz von der Schlange entfernt ist).
Die neue Maus wird platziert und die Schlange darf weitersuchen.
So, die Sache ist jetzt fertig würde ich sagen. Die Schlange beginnt
willkürlich in der Matrix mit einer Länge von 2 LEDs. Sie krabbelt durch
die Matrix und ändert willkürlich die Richtung ohne dabei zu hektisch zu
wirken. Trifft sie dabei auf die zufällig platzierte Maus, wird die
Schlange ein Element länger. Die Schlange wird grün, die Maus rot
dargestellt. Die Schlange kann nicht rückwärts laufen. Trifft die
Schlange auf eine der Aussenkanten hat das Zufallsptinzip 5 Versuche die
Richtung zu wechseln (Ecken sind besonders schwierig für den
Zufallsgenerator). Schafft die Schlange es nicht, werden nochmal alle
Richtungen überprüft
ob sie frei sind, wenn nicht hat sich die Schlange aufgewickelt und das
Spiel beginnt von vorn.
Die CPU läuft mit 8MHz und ist ca zu 8% ausgelastet... Ich hätte mit
mehr gerechnet...
Thread beobachten
Seitenaufteilung abschalten