✔ Mausklicks abfragen und auswerten

T

tetzlaff

Grünschnabel
Ich bin Anfänger in C++. Ich möchte Mausklicks abfragen und auswerten.
Zum Beispiel auf ein rotes Rechteck geklickt = 3.
Wie mache ich dieses rote Rechteck aktiv für die Maus.

Bitte mit Programmcode und Erklärung ausführlich und so einfach wie möglich antworten.
 
hmm, also wenn es sich um eine reine Konsolenanwendung handelt (im Stil vom Windows Explorer) kannst du die Maus eh nicht verwenden so weit ich weiß.
Da du jedoch von roten Rechtecken sprichst, kann dies eigentlich nicht gemeint sein, denn da gibt's ja nur schwarz und weiß.

Im allgemeinen ist das relativ einfach. Mit dem Klassenassitenten erstellst du die Funktion OnLButtonDown(UINT nFlags, CPoint point) . (Dazu Message WM_LButtonDown benutzen) Diese Funktion wird nun jedes mal aufgerufen, wenn die Maus irgendwo geklickt wird.

Um herauszufinden worauf geklickt wurde gibt dir die Funktion die x,y-Koordinate in der Variable point (im Format CPoint). Die gezeichneten Rechtecke habe ja auch x,y-Koordinaten, so dass du nur überprüfen musst ob point.x und point.y innerhalb der Koordinaten der Rechtecke liegen. (Dies alles in der Funktion OnLButtonDown)
 
hier noch'n Beispiel aus dem was ich gerade schreibe

Code: 
void CMyGameView::OnLButtonDown(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
	CMyGameDoc* pDoc = GetDocument();	//Zeiger auf CMyGameDoc

	//Nur Ausführen, wenn Spieler an der Reihe ist und das Spiel läuft
	if(pDoc->NextIsPlayer && pDoc->RunningGame)
	{

		//Gerätekontext holen
		CClientDC dc(this);

		CMyGameDoc* pDoc = GetDocument();	//Zeiger auf CMyGameDoc

		CPoint PointOnBoard;

		CRect get_rect;
		GetDlgItem(IDC_STATIC_BOARD)->GetWindowRect(get_rect);
		ScreenToClient(get_rect);

		PointOnBoard.x = point.x - get_rect.left;
		PointOnBoard.y = point.y - get_rect.top;

		bool ClickOnPlayer = false, ClickOnDice = false;
		int Position, Stein;

		//Wenn auf einen Spielstein des Spielers geklickt wurde, gibt diese Schleife true zurück
		if(!pDoc->Wuerfeln)
		{
			for(int i=0; i<4; i++)
			{
				Position = pDoc->pPlayer[pDoc->PlayerId].CurrentFiguresPosition[i];
				if( (pDoc->pPlayer[pDoc->PlayerId].PossibleFiguresPositions[Position].x + RadiusSpielfigur) > PointOnBoard.x &&
					(pDoc->pPlayer[pDoc->PlayerId].PossibleFiguresPositions[Position].x - RadiusSpielfigur) < PointOnBoard.x &&
					(pDoc->pPlayer[pDoc->PlayerId].PossibleFiguresPositions[Position].y + RadiusSpielfigur) > PointOnBoard.y &&
					(pDoc->pPlayer[pDoc->PlayerId].PossibleFiguresPositions[Position].y - RadiusSpielfigur) < PointOnBoard.y )
				{
					ClickOnPlayer = true;
					Stein = i;
				}
			}
		}//End if(!pDoc->Wuerfeln)

		//Wenn gewürfelt werden darf
		if(pDoc->Wuerfeln)
		{
			CPoint Center;
			int width;
			width = 50;
	
			//Positionen der Würfel
			//für Rot
			if(pDoc->PlayerId == 0)
			{
				Center.x = Feld[27].x + ((FeldRot[0].x - Feld[27].x) / 2);
				Center.y = FeldRot[0].y + ((FeldRot[2].y - FeldRot[0].y) / 2);
			}
			//für Blau
			if(pDoc->PlayerId == 1)
			{
				Center.x = FeldBlau[1].x + ((Feld[31].x - FeldBlau[1].x) / 2);
				Center.y = FeldBlau[0].y + ((FeldBlau[2].y - FeldBlau[0].y) / 2);
			}
			//für Gelb
			if(pDoc->PlayerId == 2)
			{
				Center.x = FeldGelb[1].x + ((Feld[8].x - FeldGelb[1].x) / 2);
				Center.y = FeldGelb[0].y + ((FeldGelb[2].y - FeldGelb[0].y) / 2);
			}
			//für Grün
			if(pDoc->PlayerId == 3)
			{
				Center.x = Feld[10].x + ((FeldGruen[0].x - Feld[10].x) / 2);
				Center.y = FeldGruen[0].y + ((FeldGruen[2].y - FeldGruen[0].y) / 2);
			}
			//Wurde auf den Würfel geklickt?
			if( PointOnBoard.x >= (Center.x - (width/2)) && 
				PointOnBoard.x <= (Center.x + (width/2)) &&
				PointOnBoard.y >= (Center.y - (width/2)) &&
				PointOnBoard.y <= (Center.y + (width/2)) )
			{
				ClickOnDice = true;
			}
		}//End if(!ClickOnPlayer && pDoc->RunningGame && pDoc->Wuerfeln)

		//Wenn auf einen Spielstein geklickt wurde und auch ein Stein angeklickt werden soll, dann löse Funktion aus
		if(ClickOnPlayer && !pDoc->Wuerfeln)
		{
			pDoc->pPlayer[pDoc->PlayerId].Create(this, pDoc->PlayerId, 1, Stein);
		}//End if(ClickOnPlayer && pDoc->RunningGame && !pDoc->Wuerfeln)

		//Wenn nicht auf einen Spielstein geklickt wurde
		if(!ClickOnPlayer && !pDoc->Wuerfeln)
		{
			MyErrorMessage(pDoc->PlayerId, 10);
		}

		//Wenn gewürfelt werden darf und auf den Würfel geklickt wurde
		if(ClickOnDice && pDoc->Wuerfeln)
		{
			pDoc->pPlayer[pDoc->PlayerId].Create(this, pDoc->PlayerId, 0, 0);
			//WuerfelAuswertung();
		}

		//Wenn gewürfelt werden darf und auf den nicht Würfel geklickt wurde
		if(!ClickOnDice && pDoc->Wuerfeln)
		{
			MyErrorMessage(pDoc->PlayerId, 17);
		}

	}//End if(pDoc->NextIsPlayer && pDoc->RunningGame)
	CFormView::OnLButtonDown(nFlags, point);
}
 
moin


Sorry, aber so ein unsinn.

Klar kann man die Mausverwenden.
Und klar kann man in der Konsole rote Rechtecke zeichnen.
Und warum ein MFC Beispiel wenn er ne Konsolenanwendung schreiben will?!

Muss noch eben was gzcken dann kann ich dir ein Beispiel geben.


mfg
umbrasaxum
 
Hier ist auch ein bsp für Maus in der Konsole:


Code: 
#include <windows.h>
#include <stdio.h>
int main()
{
 HANDLE hStdIn = GetStdHandle(STD_INPUT_HANDLE);
 HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
 DWORD dwInputEvents;
 COORD xypos = {0,0};
 INPUT_RECORD inputBuffer;
 DWORD NRofEvents;
 DWORD dwMode;
 
 int x,y,z;
 GetConsoleMode(hStdIn, &dwMode);
  SetConsoleMode(hStdIn, dwMode|ENABLE_MOUSE_INPUT);
 while(1)
 {
   GetNumberOfConsoleInputEvents(hStdIn,&NRofEvents);
   
   if(NRofEvents>0)
   {
	ReadConsoleInput(hStdIn, &inputBuffer,1,&dwInputEvents);
	
	if(inputBuffer.EventType==MOUSE_EVENT)
	{
	 x=inputBuffer.Event.MouseEvent.dwMousePosition.X;
	 y=inputBuffer.Event.MouseEvent.dwMousePosition.Y;
	 z=inputBuffer.Event.MouseEvent.dwButtonState;
	 _flushall();
	 
	 SetConsoleCursorPosition(hStdOut,xypos);
	 printf("X> %2d\nY> %2d\nZ> %2d",x,y,z);
	}
  }
 }
 
 return 0;
}

Du kannst mit diesem bsp. die x und y koordinaten vergleichen an dem das Dreieck in der Konsole liegt, oder
du speicherst alle Zeichen in ein 2-dim char Array und prüfst diese mit den Mauskoordinaten ob der bestimmte ASCII Wert in dem Byte im Array gespeichert ist.
 
Ach Ja.

Wenn du WIN 2000 verwendest (--> mein normaler PC) musst du den QuickEdit und Einfügemodus von der Konsole deaktivieren. Dazu rechter Mausklick auf die oberste Leiste von der Konsole und Häckchen von QuickEdit und Einfügemodus entfernen

@umbrasaxum: Funktioniert eigentlich Assambler unter WIN oder liegt das an meinem Compiler (VC6).
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück