009
10.11.2004, 09:54 Uhr
~Gast
Gast
|
| Zitat von Hans: |
Im Prinzip ja, aber da musst Du eine Menge selber machen, vor allem, wenn Du ein "Tastatur-echo" haben willst. Tastatur-echo bedeutet, das man sieht, welche Taste gerade gedrückt wurde.
Du brauchst eine "Cursor-Position", weil Du den nämlich selber Verwalten musst, und einen Eingabe-puffer. Eine Eingabefunktion könnte etwa so aussehen:
* mit outtextxy() den Text ausgeben, der besagt, das eine Eingabe erwartet wird. Die Länge des Textes, d.h. die Anzahl der ausgegebenen Zeichen merken, denn die musst Du zur x-position dazu zählen, wo Dein Tastaturecho erscheinen soll.
* eingabepuffer leeren.
* mit getch() ein Zeichen lesen.
* eventuell auf Gültigkeit prüfen. - Wenn Du z.B. keine Buchstaben haben willst, kannst Du sie hier sofort abblocken.
* Zeichen in den Eingabepuffer schreiben, und mit outtextxy() da ausgeben, wo man es erwartet: Hinter der Aufforderung dazu.
* dies wiederholst Du so lange, bis auf "Enter" gedrückt wird.
* in den Eingabepuffer jetzt ein Null-byte ans Ende hängen.
* jetzt kannst Du den Eingabepuffer noch mal überprüfen, (oder auch nicht) und dann z.B. mit sscanf() oder atoi() in eine Variable übernehmen.
Es bietet sich an, dafür eine eigene Funktion zu schreiben, der man die selben Daten übergibt, die auch outtextxy erwartet, die einem aber als Ergebniss das zurückliefert, was der User eingegeben hat. Dann kann man den Eingabepuffer und die Variablen für die Cursorposition lokal verwalten, was die Sache flexibler machen sollte.
|
Hallo Hans, Du konntest mir schon helfen, auch die XOR-Verknüpfung hast Du gut erklärt aber ich glaube das ist mir dann vorerst doch etwas zu kompliziert mit dem Einlesen von Zeichen.
Habe gestern den Quelltext etwas umgeschrieben und einiges in die main Funktion verlegt.
Man kann einen Lichtstrahl der von links nach rechts über den Bildschirm geht mit den Tasten 8 und 2 nach oben und unten steuern.
| C++: |
/******************************************************************/
/* Headerdateien */
/******************************************************************/
#include <graphics.h> /* Wird fuer Grafik benoetigt */
#include <stdio.h> /* Standard Ein Ausgabe */
#include <conio.h>
#include <stdlib.h> /* exit */
#include <math.h> /* sin, cos */
#include <dos.h> /* delay */
/******************************************************************/
/* Globale Variablen */
/******************************************************************/
int errorcode, graphdriver, graphmode, x1= 0, y=0;
float a= 0; /* Winkel fuer Spiegel */
/******************************************************************/
/* Funktionen */
/******************************************************************/
void graphinit(void)
{
int gdriver = 9; /* Grafiktreiber - 9 = VGA */
int gmode = 1; /* Grafikmodus - 1 = 640x350 16 color 2 */
int errorcode; /* Variable fuer Fehlercode */
/* Grafikmodus wird initialisiert. (Treiber, Modus, Treiberverzeichnis */
initgraph(&gdriver, &gmode, "");
errorcode = graphresult(); /* Grafik Fehlercode */
if (errorcode != grOk) /* Falls Grafikfehler... */
{
printf("Grafikfehler: %s\n", grapherrormsg(errorcode));
printf("Zum Beenden Taste druecken.");
getch();
exit(1); /* Programm Ende mit Errorcode */
}
}
void rahmen()
{
/* Rahmen */
rectangle(0,10,getmaxx(),getmaxy());
outtextxy(0,0,"Strahlengang im rotierenden Spiegel");
}
void strahl (void)
{
if (x1 <= getmaxx())
{
moveto(0,100+y);
x1= x1+ 3;
lineto(x1,100+y);
}
else x1= 0;
}
void spiegel (void)
{
int posX = getmaxx()/2; /* X-Position der Spiegelmitte */
int posY = getmaxy()/2; /* Y-Position der Spiegelmitte */
int laenge = 100; /* Laenge des Spiegel in Pixel */
float step = 0.01; /* Geschwindigkeit der Drehung */
double sinA, cosA; /* Variablen fuer Winkelfunktion*/
char msg[6];
sinA= sin(a);
cosA= cos(a);
line (posX - laenge*cosA, posY - laenge*sinA, posX + laenge*cosA, posY + laenge*sinA);
if (a <= 6.283)
{
a= a + step;
}
else
{
a= 0;
}
sprintf(msg, " (%.2f)",a);
outtextxy(getmaxx()-70,0, msg);
}
/******************************************************************/
/* Hauptprogramm */
/******************************************************************/
void main(void)
{
char SeitenNr = 0; /* Nummer der Seite fuer PAGING */
graphinit(); /* Grafikinitialisierung */
while (1)
{
if (kbhit())
{
switch(getch())
{
case 27:
{
closegraph();
exit(1);
}
case 50:
{
y++;
break;
}
case 56:
{
y--;
break;
}
}
}
setvisualpage(SeitenNr);
setactivepage(SeitenNr^1); /* Umkehrung durch XOR-Verknuepfung */
rahmen();
spiegel();
strahl();
clearviewport();
rahmen();
spiegel();
strahl();
SeitenNr = (SeitenNr^1); /* Umkehrung durch XOR-Verknuepfung */
}
}
|
Jetzt müßte ich eine Kollisionsabfrage einbauen, d.h. wenn der Lichtstrahl auf den rotierenden Spiegel trifft, soll er erstmal abbrechen und nicht bis zum rechten Bildschirmrand laufen. Würde der Speigel sich nicht drehen, wäre es ja gar nicht so schwer, sogesehen kollidiert der Strahl ja schon mit dem rechten Bildschirmrand und fängt dann wieder von links neu an. Wie das mit einer sich drehenden Linie funktioniert weiß ich nicht. Habe mir auch schon gedacht, dass man vielleicht wie Du gesagt hast den Spiegel ausschneiden muß und ihn dann als Bild abzuspeichern. Dann dreht man am Ende nur das Bild und könnte vielleicht eine Kollision mit dem Bild erzeugen. Im Internet hatte ich etwas darüber gelesen, das man den Bildschirm in Sektoren aufteilen muß usw, dass wäre für mich als Anfänger aber wohl auch wieder zu kompliziert. Wie gehe ich am besten an die Sache ran? |
