Herangehensweise - mit vielen Variablen arbeiten

[Nordevil]

Hallo,

ich habe eine Frage zur grundsätzlichen Herangehensweise, bzw. dem Handling mit vielen Variablen.

In meinem Programm möchte ich die Farben von bestimmten Pixeln auslesen. Da die Pixel immer nur an bestimmten Positionen bestimmte Farben haben, habe ich somit viele Variablen, die jeweils einen Punkt darstellen. Wie implementiere ich das am besten?

Wäre es sinnvoll eine Locations-Klasse zu machen in der alle Variablen mit Gettern und Settern drin stehen? Macht es vielleicht eher Sinn die ganzen Variablen in eine Datenbank zu packen und sie von dort aus immer auszulesen? Kann ich das ganze dynamisch gestalten? Da der Desktop quasi in vier Teile unterteilt ist und die Punkte in diesen vier Bereichen immer an der selben Stelle stehen, würde es ja reichen, wenn man die kompletten Koordinaten des ersten Viertels hätte. Danach könnte man die anderen Punkte dann ja berechnen. Ist es im Falle einer Klasse sinnvoll die Punkte sofort im Konstruktor zu initialisieren?

Meiner Meinung nach sollten alle Werte zentral irgendwo abgelegt sein, damit man sie im Falle des Falles schnell editieren kann und nicht lange im Code suchen muss.

Über Hilfe würde ich mich sehr freuen. Vielen Dank schon einmal im Voraus!


Greetz
Nordevil

 

[sliwalker]

Hoi,

ich muss zugeben, ich habe nicht ganz verstanden was Du willst.

Ist Array, List oder Hashmap vielleicht eine Antwort für Dich?

Ob Du etwas im Konstruktor initialisieren sollst oder nicht, ist ja stark davon abhängig, was mit der variablen gemacht wird und ob sie eine Standardinitilisierung bekommen darf oder im Falle einer Referenzvariablen nicht lieber null sein sollte.

Das kann man so pauschal nicht sagen.
Aber als Hinweis. Primitive Datentypen werden von der Runtime initialisiert, sofern sie Klassenvariablen sind. Ein int zB mit 0. Das gilt nicht für lokale Variablen in Methoden, da hast Du Schrott, Nix oder was auch immer drin stehen.

Versuch nochmal bitte Dein prblem zu schildern, aber als ob Du es Deiner Oma erzählen würdest, die keine Ahnung vom PC hat

greetz
SLi

 

[Nordevil]

Hallo sliwalker,

danke für den Versuch, das Ganze zu verstehen. :wink: Ich versuche es nochmal!

Also ich möchte einen Bot schreiben, der z.B. Hearts, Solitaire, Poker, was auch immer spielt. Da ich keine Programmmier-Schnittstelle zu diesen Programmen habe, ist es mir im Moment nur möglich aufgrund einer Grafikanalyse, bzw Desktopanalyse auf bestimmte Situationen zu reagieren. Das soll heißen, dass wenn z.B. ein bestimmter Button in dem Programmfenster auftaucht, ich darauf reagieren möchte. Um den Button zu erkennen, nehme ich mir im Moment zwei Punkte raus, die eine bestimmte Farbe haben, z.B. rot. Ist der Button nicht da, dann hat derselbe Punkt meinetwegen die Farbe grün. Da es ja mehrere Buttons und natürlich auch Karten etc. gibt, kommen so natürlich viele Punkte zusammen, die bei bestimmten Situationen auf ihren Farbwert hin ausgewertet werden müssen. Um diese vielen verschiedenen Punkte geht es nun. Für die Punkte nehme ich die Point-Klasse (int x, y) und für die Farben die Color-Klasse (int r, g, b). Zum Auslesen der Farbwerte an bestimmten Punkten nehme ich die Robot-Klasse.

Hinzu kommt noch, dass ich später auch z.B. beim Pokern mehrere Tische gleichzeitig bespielen möchte. Das würde bedeuten, dass sich die Punkte untereinander nicht unterscheiden, sie halt nur nach rechts oder nach unten verschoben sind.

Die Frage ist nun, wie ich mit diesen vielen Punkten am besten umgehe? Sollte ich eine Klasse machen, die alle Punkte beinhaltet? Wie kann ich die Punkte am besten berechnen. Ich habe mir schon überlegt, dass ich einen "Root-Punkt" setzen könnte, aus dem sich dann die anderen Punkte berechnen. Wenn ich denn mehrer Tische hätte, dann brächte nur der Rootpunkt geändert zu werden.

Fragen über Fragen, aber dafür ist das Forum ja hoffentlich da.

Ich hoffe, ich konnte nun mehr Licht ins Dunkle bringen und bin schon gespannt auf die Ideen und Anregungen.


Greetz
Nordevil

 

[moormaster]

Da es ja mehrere Buttons und natürlich auch Karten etc. gibt, kommen so natürlich viele Punkte zusammen, die bei bestimmten Situationen auf ihren Farbwert hin ausgewertet werden müssen.

Das lässt sich doch mit Objektorientierter Programmierung prima Kapseln, indem du z.B. eine Klasse Window erstellst, die sich eine Fensterposition merken kann.

Nun kannst du entsprechend eine Klasse Button dahernehmen, welche die Position eines Buttons innerhalb eines Fensters sowie eine Referenz auf ein Window-Objekt speichern kann. D.h. der Button weiss über die Window-Referenz, in welcher Position sich sein Fenster befindet und er kennt seine Position innerhalb dieses Fensters; man kann also jederzeit auf diese Weise die absolute Position auf dem Monitor ausrechnen.

Dann kannst du in dieser Klasse Methoden definieren, die herausfinden (anhand der Pixelfarben an bestimmten Positionen), ob der Button sichtbar ist, gedrückt ist oder was auch immer.

Da es ja sicherlich nicht nur eine Sorte Buttons gibt, die du überprüfen möchtest, bietet es sich natürlich an, die Klasse Button nur als Oberklasse zu verwenden und von dieser dann weitere Klassen abzuleiten... z.B. HeartsButton, PokerAllInButton oder sowas eben.

Hinzu kommt noch, dass ich später auch z.B. beim Pokern mehrere Tische gleichzeitig bespielen möchte. Das würde bedeuten, dass sich die Punkte untereinander nicht unterscheiden, sie halt nur nach rechts oder nach unten verschoben sind.

Hier würden sich dementsprechend die Window Klassen nützlich machen, die ich schon erwähnt hab. Evtl. ist es nützlich ebenfalls verschiedene Windowklassen zu bauen (HeartsWindow, PokerWindow...), welche dann die jeweiligen Buttons usw. im Konstruktor gleich anlegen mit den entsprechenden Positionen. Somit währen die Buttonpositionen dann auch an "zentraler" Stelle... nämlich jeweils in den von Window erbenden Klassen.

 

[Nordevil]

Hallo moormaster,

vielen Dank für die ausführliche Antwort! Aber wenn ich das richtig verstanden habe, dass sind die Koordinaten von den einzelnen Objekten (z.B. Button) ja über alle Klassen verteilt. Wenn sich die Positionen von Objekten (z.B. andere Anordnung des Festerinhaltes nach einem Update) dann mal ändern sollten, dann müsste ich ja alle Objektklassen durchgehen, und die Koordinaten ändern, da die ja nach Deiner Ausführung nicht zentral irgendwo bestimmt sind. Habe ich da evtl. etwas missverstanden?


Greetz
Nordevil

 

[moormaster]

Hallo moormaster,

vielen Dank für die ausführliche Antwort! Aber wenn ich das richtig verstanden habe, dass sind die Koordinaten von den einzelnen Objekten (z.B. Button) ja über alle Klassen verteilt. Wenn sich die Positionen von Objekten (z.B. andere Anordnung des Festerinhaltes nach einem Update) dann mal ändern sollten, dann müsste ich ja alle Objektklassen durchgehen, und die Koordinaten ändern, da die ja nach Deiner Ausführung nicht zentral irgendwo bestimmt sind. Habe ich da evtl. etwas missverstanden?

Nun: Ja, da hast du was nicht ganz verstanden.

Die Objekte, die Buttons etc. repräsentieren, sollen Koordinaten nur speichern können. Im Konstruktor werden die objektspezifischen Daten, wie die Koordinaten, erst festgelegt.

Du hast also z.B. eine PokerWindow Klasse, die sich die entsprechenden Objekte anlegt und merkt.
Dort werden also solche Dinge, wie Koordinaten, relativ zum Fenster, erst festgelegt.

Die Koordinaten aller Objekte einer Sorte von Fenstern befinden sich also zentral im Konstruktor der jeweiligen Window-Klasse.

 

[Nordevil]

Ah, Ok, ich glauch so langsam hab ich das begriffen. Wenn alle Koordinaten in der Window-Klasse definiert werden, dann übergebe ich jeweils die entsprechenden Koordinaten, wenn ich ein neues Objekt erzeuge, so dass das neue Objekt mit den übergebenen Koordinaten erzeugt werden kann.

Ist das eigentlich performanceunabhägig, ob ich nun viele oder wenig Variablen übergebe?