TicTacToe mit MFC - Anpassung der Spielfeldgröße an Clientgröße

S

Stay Tuned

Grünschnabel
Hi

Wir sind in der Schule grade dabei TicTacToe mit MFC zu programmieren und sind nun so weit, dass wir die Spielfeldgröße dem Client anpassen müssen.

Dazu sollen wir die CWind-Methode GetClientRect( ) benutzen.


Das Spielfeld soll immer 20% kleiner sein als der aktuelle Client und soll sich natürlich mit ihm zusammen vergrößern und verkleinern.

Nun weiß ich leider nicht genau wie ich dies realisieren soll...

Hier mal meine aktuelle Viev.cpp ( ziemlich groß )

Code: 
// TTTView.cpp : Implementierung der Klasse CTTTView
//

#include "stdafx.h"
#include "TTT.h"

#include "TTTDoc.h"
#include "TTTView.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CTTTView

IMPLEMENT_DYNCREATE(CTTTView, CView)

BEGIN_MESSAGE_MAP(CTTTView, CView)
	//{{AFX_MSG_MAP(CTTTView)
	ON_WM_LBUTTONDOWN()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CTTTView Konstruktion/Destruktion

CTTTView::CTTTView()
{
	// ZU ERLEDIGEN: Hier Code zur Konstruktion einfügen,

//GROßES FELD
	for(int i=0; i<3; i++){
		for(int j=0; j<3; j++){
			m_feld[i][j].top=100+(i*100);
			m_feld[i][j].left=100+(j*150);
			m_feld[i][j].bottom=m_feld[i][j].top+100;
			m_feld[i][j].right=m_feld[i][j].left+150;
			m_player = 1;
		
		}
	}

//KLEINES FELD
			m_mini.top=220;
			m_mini.left=600;
			m_mini.bottom=m_mini.top+50;
			m_mini.right=m_mini.left+100;
			m_mini.m_farbe = RGB ( 0,0,255 );

	m_unentschieden = 0;
	m_count_blau = 0;
	m_count_rot = 0;
	m_win = 0;
}

CTTTView::~CTTTView()
{

}

BOOL CTTTView::PreCreateWindow(CREATESTRUCT& cs)
{
	// ZU ERLEDIGEN: Ändern Sie hier die Fensterklasse oder das Erscheinungsbild, indem Sie
	//  CREATESTRUCT cs modifizieren.

	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CTTTView Zeichnen

int CTTTView::werHatGewonnen(){

	//feld 0|0 0|1 0|2
		if(m_feld[0][0].m_farbe==RGB(255,0,0)&&m_feld[0][1].m_farbe==RGB(255,0,0)&&m_feld[0][2].m_farbe==RGB(255,0,0)){
			m_win = 2;
			return m_win;
		}
		else if(m_feld[0][0].m_farbe==RGB(0,0,255)&&m_feld[0][1].m_farbe==RGB(0,0,255)&&m_feld[0][2].m_farbe==RGB(0,0,255)){
			m_win = 1;
			return m_win; 
		}
	//feld 1|0 1|1 1|2
		if(m_feld[1][0].m_farbe==RGB(255,0,0)&&m_feld[1][1].m_farbe==RGB(255,0,0)&&m_feld[1][2].m_farbe==RGB(255,0,0)){
			m_win = 2;
			return m_win;	
		}
		else if(m_feld[1][0].m_farbe==RGB(0,0,255)&&m_feld[1][1].m_farbe==RGB(0,0,255)&&m_feld[1][2].m_farbe==RGB(0,0,255)){
			m_win = 1;
			return m_win;
		}
	//feld 2|0 2|1 2|2
		if(m_feld[2][0].m_farbe==RGB(255,0,0)&&m_feld[2][1].m_farbe==RGB(255,0,0)&&m_feld[2][2].m_farbe==RGB(255,0,0)){
			m_win = 2;
			return m_win;
		}
		else if(m_feld[2][0].m_farbe==RGB(0,0,255)&&m_feld[2][1].m_farbe==RGB(0,0,255)&&m_feld[2][2].m_farbe==RGB(0,0,255)){
			m_win = 1;
			return m_win;
		}
	//feld 0|0 1|0 2|0
		if(m_feld[0][0].m_farbe==RGB(255,0,0)&&m_feld[1][0].m_farbe==RGB(255,0,0)&&m_feld[2][0].m_farbe==RGB(255,0,0)){
			m_win = 2;
			return m_win;	
		}
		else if(m_feld[0][0].m_farbe==RGB(0,0,255)&&m_feld[1][0].m_farbe==RGB(0,0,255)&&m_feld[2][0].m_farbe==RGB(0,0,255)){
			m_win = 1;
			return m_win;
		}
	//feld 0|1 1|1 2|1
		if(m_feld[0][1].m_farbe==RGB(255,0,0)&&m_feld[1][1].m_farbe==RGB(255,0,0)&&m_feld[2][1].m_farbe==RGB(255,0,0)){
			m_win = 2;
			return m_win;	
		}
		else if(m_feld[0][1].m_farbe==RGB(0,0,255)&&m_feld[1][1].m_farbe==RGB(0,0,255)&&m_feld[2][1].m_farbe==RGB(0,0,255)){
			m_win = 1;
			return m_win;
		}
	//feld 0|2 1|2 2|2
		if(m_feld[0][2].m_farbe==RGB(255,0,0)&&m_feld[1][2].m_farbe==RGB(255,0,0)&&m_feld[2][2].m_farbe==RGB(255,0,0)){
			m_win = 2;
			return m_win;	
		}
		else if(m_feld[0][2].m_farbe==RGB(0,0,255)&&m_feld[1][2].m_farbe==RGB(0,0,255)&&m_feld[2][2].m_farbe==RGB(0,0,255)){
			m_win = 1;
			return m_win;
		}
	//feld 0|0 1|1 2|2
		if(m_feld[0][0].m_farbe==RGB(255,0,0)&&m_feld[1][1].m_farbe==RGB(255,0,0)&&m_feld[2][2].m_farbe==RGB(255,0,0)){
			m_win = 2;
			return m_win;	
		}
		else if(m_feld[0][0].m_farbe==RGB(0,0,255)&&m_feld[1][1].m_farbe==RGB(0,0,255)&&m_feld[2][2].m_farbe==RGB(0,0,255)){
			m_win = 1;
			return m_win;
		}
	//feld 0|2 1|1 2|0
		if(m_feld[0][2].m_farbe==RGB(255,0,0)&&m_feld[1][1].m_farbe==RGB(255,0,0)&&m_feld[2][0].m_farbe==RGB(255,0,0)){
			m_win = 2;
			return m_win;	
		}
		else if(m_feld[0][2].m_farbe==RGB(0,0,255)&&m_feld[1][1].m_farbe==RGB(0,0,255)&&m_feld[2][0].m_farbe==RGB(0,0,255)){
			m_win = 1;
			return m_win;
		}
		return 0;
}


void CTTTView::OnDraw(CDC* pDC)
{
	CTTTDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	// ZU ERLEDIGEN: Hier Code zum Zeichnen der ursprünglichen Daten hinzufügen

//GROßES FELD
	for(int i=0; i<3; i++){
		for(int j=0; j<3; j++){

			m_strich.CreatePen(PS_SOLID,m_feld[i][j].m_rand,RGB(0,0,0));
			m_grau.CreateSolidBrush(m_feld[i][j].m_farbe);

			CPen* pOldPen=pDC->SelectObject(&m_strich);
			CBrush* pOldBrush=pDC->SelectObject(&m_grau);

			pDC->Rectangle(m_feld[i][j]);

			pDC->SelectObject(pOldPen);
			pDC->SelectObject(pOldBrush);

			m_strich.DeleteObject();
			m_grau.DeleteObject();
		}
	}


	
//KLEINES FELD

			m_strich.CreatePen(PS_SOLID,m_mini.m_rand,RGB(0,0,0));
			m_grau.CreateSolidBrush(m_mini.m_farbe );

			CPen* pOldPen=pDC->SelectObject(&m_strich);
			CBrush* pOldBrush=pDC->SelectObject(&m_grau);

			pDC->Rectangle(m_mini);

			pDC->SelectObject(pOldPen);
			pDC->SelectObject(pOldBrush);

			m_strich.DeleteObject();
			m_grau.DeleteObject();



//ANPASSUNG DES SPIELFELDES AN DEN CLIENT  ( BETA - NICHT FERTIG )

			GetClientRect(cr);
			m_feld[i][j].left=cr.right * 0,2; //Die 0,2 sind die 20 Prozent
			m_feld[i][j].top=cr.bottom * 0,2;
			m_feld[i][j].right=m_feld[0][0].left+cr.right * 0,2;
			m_feld[i][j].top+cr.bottom * 0,2;

//AUSGABE
			CString str;
			if( m_win == 1){

				str.Format("Blau hat nach %i Zuegen gewonnen.", m_count_blau );
				pDC->TextOut(200,50,str);
			}
			if( m_win == 2){

				str.Format("Rot hat nach %i Zuegen gewonnen.", m_count_rot );
				pDC->TextOut(200,50,str);
			}
//UNENTSCHIEDEN

			if( m_unentschieden == 9 && m_win != 1 && m_win != 2){

				str.Format("Unentschieden" );
				pDC->TextOut(200,50,str);
			}



}


/////////////////////////////////////////////////////////////////////////////
// CTTTView Diagnose

#ifdef _DEBUG
void CTTTView::AssertValid() const
{
	CView::AssertValid();
}

void CTTTView::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

CTTTDoc* CTTTView::GetDocument() // Die endgültige (nicht zur Fehlersuche kompilierte) Version ist Inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CTTTDoc)));
	return (CTTTDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CTTTView Nachrichten-Handler

void CTTTView::OnLButtonDown(UINT nFlags, CPoint point) 
{
	// TODO: Code für die Behandlungsroutine für Nachrichten hier einfügen und/oder Standard aufrufen
	
	if( m_win == 0 ){
		for(int i=0; i<3; i++){
			for(int j=0; j<3; j++){

				if(m_feld[i][j].PtInRect(point)&&m_feld[i][j].m_farbe == RGB ( 100,100,100)){

					if(m_player == 1 ){
							m_feld[i][j].m_farbe = RGB ( 0,0,255);
							m_mini.m_farbe = RGB ( 255,0,0);
							m_count_blau++;
							m_unentschieden++; // FÜR UNENDSCHIEDEN
							m_win = werHatGewonnen();

							m_player = 2;
					}
				
					else{
							m_feld[i][j].m_farbe = RGB ( 255,0,0);
							m_mini.m_farbe = RGB ( 0,0,255 );
							m_count_rot++;
							m_unentschieden++; // FÜR UNENTSCHIEDEN
							m_win = werHatGewonnen();

							m_player = 1;
					}
				}
				
				
				this->Invalidate();
			}
		}
		
	}
			
	CView::OnLButtonDown(nFlags, point);
}


Der in rot dargestellte Teil des Codes ist das woran ich grade arbeite...

Ansich verstehe ich was GetClientRect macht, aber die umsetzung in validen C++ Code schaffe ich irgendwie nicht. Jede Idee die ich bisher hatte funktioniert nicht.

Kann mir wer sagen was ich hier tun muss, damit das ganze endlich funktioniert?


Mit freundlichen Grüßen

Stay Tuned
 
Hat niemand kurz Zeit mir zu helfen?

Ich komme von alleine immernoch nicht auf die Lösung und könnte ein paar hilfreiche Tipps gebrauchen.


Danke
 
Hi,

prinzipiell hast du schon den richtigen Ansatz.
Im Klaren mußt du dir darüber sein, wo deine Koordinaten sind. GetClientRect(rc) gibt dir die Größe des gesamten Client-Bereiches. Um die richtige Größe deines Spielfeldes zu berechnen, mußt du von Höhe und Breite jeweils 20% abziehen und, da du drei Felder in der Höhe und Breite haben mußt, noch durch 3 teilen.
Code: 
int hoehe=(rc.Height()-rc.Height()*0,2)/3;
int breite=(rc.Width()-tc.Width()*0,2)/3;

Damit hast du die Länge und Breite eines Feldes. Gleichzeitig mußt du aber berücksichtigen, dass der top-left-Punkt vom ersten Feld 10 % vom Rand entfernt ist.
Code: 
int offsethorizontal=rc.Width()*0,1;
int offsetvertikal=rc.Height()*0,1;

Dann kanst du die Koordinaten berechnen
Code: 
m_feld[i][j].left=breite*i+offsethorizontal;
m_feld[i][j].top=hoehe*j+offsetvertikal;
m_feld[i][j].right=m_feld[i][j].left+breite;
m_feld[i][j].bottom=m_feld[i][j].top+hoehe;

Mfg

langer
 
Zuletzt bearbeitet:
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück