[Bisasam]

Hab mir grad das Button-Paket von LeGo angeschaut und ein paar Experimente gemacht.

Hab mit Button_Create einen Button erstellt.

Mit Button Show hab ich dann den Button auch anzeigen lassen.

Aber da ich keinen Mauszeiger habe, kann ich natürlich nicht auf den Button klicken. Wollte dann mit Button_Activate arbeiten und dieses auf Knopfdruck machen lassen. Hat nicht geklappt. Mein Knopfdruck wird zwar angenommen, aber die On_-Funktionen (allesamt mit Print versehen) werden nicht aufgerufen.

Wie aktiviere ich einen Button? Und wie kriege ich einen funktionierenden Mauszeiger hin?

Alles Fragen bezogen auf Gothic 1.

[Lehona]

Button_Activate macht nicht ganz das, was du denkst. Wenn ein Button deaktiviert ist, reagiert er nicht mehr auf die Maus. Versteckte (d.h. nicht angezeigte) Buttons sind immer deaktiviert, aber ein angezeigter Button könnte zum Beispiel auch deaktiviert sein (Beim Durchgucken der Scripte ist mir da gerade noch ein Fehler in LeGo aufgefallen, man sollte also lieber nur Button_Show bzw. Button_Hide verwenden, dass die Buttons sowohl de-/aktiviert als auch anzeigt/versteckt).

Um einen Mauszeiger zu bekommen sind für dich die Funktionen Cursor_Show(), Cursor_Hide() und SetMouseEnabled() sowie die Variable Cursor_NoEngine interessant. Die ersten beiden sollten klar sein. Cursor_NoEngine verhindert, dass die Kamera sich dreht wenn man die Maus bewegt. SetMouseEnabled() ist eventuell bei Leuten relevant, die nicht mit der Maus spielen (und die Maussteuerung daher in den Optionen ausgeschaltet haben). Das erste Beispiel zum Cursor zeigt es eigentlich recht gut (insbesondere, weil es - im Gegensatz zum Beispiel bei den Buttons - tatsächlich existiert).

Der Cursor verwendet übrigens die Cursor.tga, die eigentlich in jedem Release von LeGo enthalten sein sollte.

[Bisasam]

Ja in dem Beispiel wurde mit View gearbeitet statt mit Button_Create. Das hat mich irritiert.

Hatte voll vergessen dass der Mauszeiger nicht Mouse sondern Cursor genannt wird und hab deswegen das Cursorpaket voll übersehen.
Allerdings gibts einen Fehler bei Button_Create. Wenn ich als X und Y Koordinate 50 angebe und die Texturmaße auf 256x256, dann erscheint die Textur erstens nicht in der Mitte vom Bildschirm sondern oben links in der Ecke mit ein paar wenigen Pixeln Abstand und zweitens ist sie nicht 256x256 groß sondern kleiner. Scheint als ob da was bei der Berechnung gehörig schief läuft. Das gleiche hatte ich bei View Create. Wenn man hingegen View_CreatePxl verwendet und von Anfang an Pixel draufaddiert, dann stimmts. Komisch.

Jedenfalls danke für die schnelle Antwort!

[Lehona]

Ja in dem Beispiel wurde mit View gearbeitet statt mit Button_Create. Das hat mich irritiert.

Es ist ja auch ein Beispiel zum Cursor, nicht zu den Buttons Weiter unten im Text gibt es einen Verweis auf die Buttons (zugegeben führt der Link ins nichts) mit dem Hinweis, dass es damit viel einfacher wird.

Hatte voll vergessen dass der Mauszeiger nicht Mouse sondern Cursor genannt wird und hab deswegen das Cursorpaket voll übersehen.
Allerdings gibts einen Fehler bei Button_Create. Wenn ich als X und Y Koordinate 50 angebe und die Texturmaße auf 256x256, dann erscheint die Textur erstens nicht in der Mitte vom Bildschirm sondern oben links in der Ecke mit ein paar wenigen Pixeln Abstand und zweitens ist sie nicht 256x256 groß sondern kleiner. Scheint als ob da was bei der Berechnung gehörig schief läuft. Das gleiche hatte ich bei View Create. Wenn man hingegen View_CreatePxl verwendet und von Anfang an Pixel draufaddiert, dann stimmts. Komisch.

Nur weil etwas anders funktioniert als du erwartest heißt das noch lange nicht, dass es nicht richtig funktioniert. in 95% der Fälle werden in LeGo sogenannte virtuelle Pixel/Koordinaten verwendet, bei denen der Punkt (0, 0) ganz oben links ist und (8192, 8192) ganz unten rechts. Wenn man nur tatsächliche Pixel verwenden würde, würde die Position der Views ja abhängig von der gewählten Auflösung sein - meistens nicht ganz das, was man erreichen möchte (für einige UI-Elemente macht es aber meistens Sinn eine Kombination aus virtuellen und realen Pixeln zu verwenden). Mit Print_ToVirtual bzw. Print_ToPixel kannst du zwischen den beiden Formaten konvertieren, falls du irgendwo z.B. virtuelle Koordinaten angeben musst, aber tatsächlich eine feste Anzahl von Pixeln verwenden möchtest.


Edit: Denk außerdem daran, dass View_Create* nicht die Breite/Höhe als "zweiten" Parameter nimmt, sondern ein zweites Paar Koordinaten, die die untere rechte Ecke des Views festlegen.

[Bisasam]

ja, ich hatte das doch glatt mit den Printscreen-Funktionen gleichgesetzt. Danke für die Erklärung.

Nun stehe ich vor einer Herausforderung, bei der ich nicht weiß, wie ich sie sinnvoll lösen soll. Hab schon ein paar Sachen ausprobiert, die aber nicht mit variablen Angaben funktionieren.

Ziel: Eine Matrix aus a Buttons auf der X-Achse und b Buttons auf der Y-Achse darstellen. Diese sollen mittig angeordnet werden. d.h. wenn ich 4 Buttons auf X habe, sollen 2 davon rechts der Mitte des Bildschirms sein und die anderen 2 links der Mitte des Bildschirms. Wenn ich 2 Buttons habe, soll 1 auf links und 1 auf rechts. Wenn ich 3 Buttons habe, soll einer genau in der Mitte sein und die anderen rechts und links davon im gleichen Abstand etc. An sich also ein variables System, welches mithilfe der Anzahl der Buttons automatisch berechnet, wie deren Platzierung auf dem Bildschirm sein soll.

Meine bisherige herangehensweise:
Ich arbeite mit den Pxl-Funktionen. Zuerst lasse ich mir X und Y der Bildschirmauflösung ausgeben, damit ich die richtigen Werte habe. Diese teile ich durch die Anzahl der Buttons pro Reihe bzw. Spalte. Dann addiere ich das Produkt aus der Nummer des Konkreten Buttons in dieser Reihe (z.B. Nummer 2 aus einer Reihe mit max 4 Buttons) und 64.
Bei exakt 4 Buttons funktioniert das auch. Aber bei einer veränderung des Gesamt-Wertes kommen die dümmsten verschiebungen zustande. Ich glaube, meine Logik ist da absolut verkehrt. Alleine komme ich da aber nicht weiter. Darum brauch ich Hilfe

[Lehona]

Das klingt für mich so, als wolltest du 2-4 Buttons horizontal bzw. vertikal in der Mitte des Bildschirms zentriert haben (mit irgendeinem Abstand zwischen den Buttons). Dann würde ich als erstes die gesamte Breite/Höhe dieser Matrix berechnen (d.h. total_width = a*BUTTON_WIDTH + (a-1)*BUTTON_ABSTAND), dann ziehst du die Hälfte davon von der Mitte ab (d.h. start_x = (PS_VMAX/2) - (total_width/2)). Das ist die linke Ecke des linkesten Buttons. Danach musst du dann eben den nächsten Button um BUTTON_ABSTAND+BUTTON_WIDTH nach rechts platzieren etc. Für die Höhe machst du das dann genau so.

Geht es hier um die Einblendung für ein Bau-Menü? Dann würde ich komplett mit virtuellen Pixeln arbeiten, denke ich. Allerdings könntest du auch Abstand und Breite der Buttons in realen Pixeln angeben, für die Berechnung aber in virtuelle Pixel umwandeln. Wie bereits gesagt macht es meistens Sinn für die grundsätzliche Platzierung mit virtuellen Pixeln zu arbeiten und nur für Größen (z.B. Breite des Buttons) reelle Pixel anzugeben.

Schau mal, wie weit du damit kommst und zeig dann deinen Code

[Bisasam]

Ja es geht um mein Bau-Menü. Virtuelle Pixel sind die, die von oben links 0 0 bis unten rechts 8192 8192 gehen? Ich denke dann habe ich das Prinzip verstanden.
Vielen Dank für deine Hilfe bisher. Dein Support ist echt klasse. Sobald ich den Code fertig habe, poste ich nochmal. Kann aber paar Tage dauern wegen begrenztem Internetzugang was Dateienupload angeht.

edit: Ist PS_VMAX die Pixelangabe für die Screenbreite? Da bin ich grad unsicher.

[Lehona]

Ja es geht um mein Bau-Menü. Virtuelle Pixel sind die, die von oben links 0 0 bis unten rechts 8192 8192 gehen? Ich denke dann habe ich das Prinzip verstanden.
Vielen Dank für deine Hilfe bisher. Dein Support ist echt klasse. Sobald ich den Code fertig habe, poste ich nochmal. Kann aber paar Tage dauern wegen begrenztem Internetzugang was Dateienupload angeht.

edit: Ist PS_VMAX die Pixelangabe für die Screenbreite? Da bin ich grad unsicher.

Genau. Damit man sich das nicht merken muss, gibt es PS_VMAX, das einfach den Wert 8192 beinhaltet.

Hier ist ja keiner in Eile

Edit: Vielleicht noch ganz kurz was dazu, warum man reale Pixel verwendet für Größen: Oftmals hast du ja Texturen in einer bestimmten Auflösung und möchtest die anzeigen, ohne sie zu skalieren (womit sie dann verschwommen wirken würden). Daher die Größe in realen Pixeln.

[Bisasam]

Gut ich habs mal ausprobiert. Wie gesagt kann ich an dem Rechner hier meine Skripte nicht laden weshalb ich es bestmöglich beschreiben muss.

Habe 1 zu 1 deine Formeln angewendet und das Ergebnis daraus als X-Wert für meine Buttons angegeben.
Problem ist, dass das Ergebnis zwar das Zentrum des Bildschirms ist, aber nur Buttons ohne Verschiebung würden am Zentrum landen. Wenn ich die Abstände und Weiten aufaddiere, wird das ganze rein linksbündig (also beginnend zentrum und ausbreitend nach rechts) und nicht zentriert.

Ich habe dann mal experimentiert und beschlossen, alle Weiten und Abstände, welche auf die andere Seite sollen, vom X-Wert zu subtrahieren. d.h. Gesamtbuttonzahl/2 und das dann abgezogen von den Gesamtbuttons macht die Anzahl der Buttons die die andere Seite ausmachen sollen. Dadurch ist mein Startwert quasi nicht mittig, sondern links und die Buttons breiten sich dann von dort aus aus.
So weit so gut.
Ich hab jetzt nur das Problem, dass ich nicht weiß wo ich das zweite Koordinatenpaar herkriegen soll. Breite in Pxl+X-Pos ergeben nämlich nur Blödsinn in der Praxis. Beim ersten ist die Textur noch quadratisch, beim zweiten 1.5x1 und beim dritten 2x1. Es wird also quasi immer breiter je weiter ich in meiner Nummerierung fortschreite. Dabei multipliziere ich das doch gar nicht mit der Nummer des Buttons. Ich verrechne nur mit der Position. Oder muss ich die Pixel in Positionen umrechnen? Ich bin da grad verwirrt.

[Lehona]

Code zeigen nicht vergessen. Und meinen Post vielleicht nochmal ganz genau lesen, denn meine Berechnung gibt dir den X-Startwert für den linkesten Button (falls das nicht so ist, hast du die Formel nicht korrekt angewandt) - da wird nichts komisch links- oder rechtsbündig. Deswegen habe ich nach dem Code gefragt - daran erkenne ich viel besser, wo genau das Missverständnis bei dir liegt. Ich hab meinen Vorschlag aber nochmal ein bisschen näher an funktionierenden Code gebracht:

Input: a // Horizontale Anzahl der Buttons
Konstanten: BUTTON_WIDTH, BUTTON_ABSTAND // Breite und Abstand der individuellen Buttons, in virtuellen Pixeln (ggf. aus reellen Pixeln konvertieren)
total_width = a*BUTTON_WIDTH + (a-1)*BUTTON_ABSTAND)
start_x = (PS_VMAX/2) - (total_width/2)

for i in 0 to a-1:
    Button_Create(start_x+i*(BUTTON_WIDTH+BUTTON_ABSTAND), BUTTON_WIDTH) // Das sind jetzt nur die X-Koordinate bzw. Breite, aber für die Höhe verfährst du analog

Edit: Ach jetzt verstehe ich erst, warum du es nur beschreibst. In der Zeit hättest du den relevanten Teil aber bestimmt auch abtippen können Ich denke so bringt das zumindest ziemlich wenig. Da reden wir nur aneinander vorbei.

Edit2: Pseudocode hinzugefügt. Außerdem beachten, dass Button_Create eine Breite/Höhe als zweiten Positionsparameter nimmt, anders als die Views. Ziemlich unglücklich.

[Bisasam]

Aha! Jetzt weiß ich wo der Fehler liegt. Ich dachte ich müsste die Breite weiterhin in reellen Pixeln angeben, aber sie sind in virtuellen Pixeln. Dann ists ja kein Wunder, dass meine 64x64 so klein sind. Ich muss bei Button_Create also dann nicht XPos+Weite rechnen sondern einfach von vornherein die Weite in virtuellen Pixeln z.B. 200 angeben.

Die Formeln hatte ich aber tatsächlich so wie du aufgeschrieben hast übernommen. Ich versuch mal meinen Code handschriftlich zu notieren und dann abzutippen. Kann aber bis übermorgen in der Früh dauern. Vielleicht hilft das aber auch schon.

[Lehona]

Das sind einfach zwei unterschiedliche Sachen und du musst dich entscheiden, was genau du erreichen willst. Wenn du z.B.

abstand = Print_ToVirtual(200, PS_X);

wählst, dann ist der Abstand immer 200px groß. Bei einer 800x600 Auflösung ist das also ein Viertel der Breite des Bildschirms, aber bei 1920x1080 gerade mal ein Zehntel. Wählst du stattdessen

abstand = 1000;

Dann ist der Abstand immer (ungefähr) ein Achtel der Bildschirmbreite, bei 800x600 also nur 75px aber bei 1920x1080 sind es 240px.


Natürlich musst du auch darauf achten, niemals reelle Pixel an Funktionen zu übergeben, die virtuelle Pixel erwarten (oder andersherum). Die darf man nicht vermischen, genauso wenig wie man Fahrenheit und Grad Celsius vermischt. Stattdessen muss man eben z.B. Fahrenheit in Grad Celsius umrechnen.

[Bisasam]

So ich habe fertig und der ganze Klumpatsch funktioniert astrein:

Func int PlaceButtonOnScreen(var int ButtonsPerRow, var int NumberInRow, var int ButtonsPerYAxis, var int NumberInYAxis, var int ButtonAbstand, var int ButtonsizeX, var int ButtonsizeY, var func onenter, var func onleave, var func onklick, var string Buttontex)
{

NumberInRow-=1;

NumberInYAxis-=1;

var int GesamtBreite;
var int GesamtHoehe;
var int posOnXAxis;
var int posOnYAxis;

Gesamtbreite=ButtonsPerRow*ButtonsizeX+((Buttonsperrow-1)*ButtonAbstand);

GesamtHoehe=ButtonsPerYAxis*ButtonsizeY+((ButtonsPerYAxis-1)*ButtonAbstand);

PosOnXAxis=(PS_VMax/2)-(Gesamtbreite/2);

PosOnXAxis=PosOnXAxis+(NumberInRow*(ButtonSizeX+ButtonAbstand));

PosOnYAxis=(PS_VMAX/2)-(Gesamthoehe/2);

PosOnYAxis=PosOnyAxis+(NumberInYAxis*(ButtonsizeY+ButtonAbstand));

var int ButtonPtr;

ButtonPtr=Button_Create(PosOnXAxis, PosOnYAxis, ButtonsizeX, ButtonsizeY,ButtonTex,onenter,onleave,onklick);
Button_Show(ButtonPtr);
return Buttonptr;
};

Alles vom handschriftlichen abgetippt. Tippfehler möglich.

Die subtraktion findet am Anfang statt damit Button 1 auch wirklich richtig zentriert wird. So kann man PlaceButtonOnScreen(4,1,4,1,256,512,512,nothing,nothing,nothing,"Sheep_Body.tga" ); verwenden und weiß immer an welcher Nummer man ist.

[Bisasam]

Anscheinend sind Buttons inkompatibel mit Tagebucheinträgen.

Ich habe eine if-Abfrage in meiner onklick drin, die bei Erfüllung einen B_LogEntry macht. Die Abfrage ist bloß if MeineVariableX==TRUE und beinhaltet keine Enginecalls.

Wenn die Abfrage nicht erfüllt ist, läuft alles wunderbar. Aber sobald das Ding auf TRUE gestellt wird und B_LogEntry aufgerufen wird, gibts nen Absturz. Stacktrace sagt mir, dass es an Buttons_DO liegt.
Oder geht hero bei Buttoncreate verloren? Dann müsste der aber bei Button_Create SOFORT abschmieren, denn in meiner Frameschleife hab ich noch viel öfter Abfragen mit hero.