FreitagsrundenWiki - Benutzerbeiträge [de]

C-Kurs/Pong

2014-09-19T09:21:48Z

130.149.245.244: /* Kommentare */

Hier soll das Spiel Pong Schritt für Schritt implementiert werden. Die Anzeige des Spielfelds soll durch ASCII-Zeichen realisiert werden, sodass das Spiel in einem Terminal laufen kann. Ein Beispiel-Screenshot könnte so aussehen:
<pre> 4 2
+----------------------------------------+
| |
| |
|# |
|# |
|# |
| * |
| |
| #|
| #|
| #|
| |
| |
| |
| |
| |
+----------------------------------------+</pre>

Leider ist es nicht ganz einfach, einzelne Tasten einzulesen, wie sie gebraucht werden, wenn der Benutzer den Schläger bewegen möchte. <tt>scanf</tt> arbeitet gepuffert und gibt die Eingabe erst nach Betätigung der Enter-Taste an das Programm. Wir verwenden deswegen die C-Programmbibliothek ''curses'', die uns entsprechende Funktionen zum Abfragen eines Tastendrucks liefert. im CS-Netz ist schon alles nötige installiert. Solltest du Linux benutzen, musst du das Entwicklerpacket von libncurses installieren (unter Debian/Ubuntu ''libncurses-dev'').

== Aufgabe ==
=== curses initialisieren ===
Erstmal müssen wir das Headerfile für ''curses'' includen:
<pre> #include <curses.h> </pre>

Schreibe jetzt eine Funktion ''void init()'', die für das Initialisieren von curses zuständig wird. Sie enthält folgende Befehle:
* <tt>initscr();</tt> aktiviert curses
* <tt>noecho();</tt> damit Buchstaben der getippten Tasten nicht im Terminal erscheinen
* <tt>cbreak();</tt> deaktiviert das Puffern der Terminalzeile
* <tt>keypad(stdscr, TRUE);</tt> aktiviert spezielle Tasten, wie die Pfeiltasten
* <tt>nodelay(stdscr, TRUE);</tt> damit die Funktion, die später die Tastendrücke entgegennimmt, nicht blockiert, bis eine Taste gedrückt wird

Jetzt folgt die <tt>main</tt>-Funktion. Sie enthält als ersten Aufruf unsere <tt>init</tt>-Funktion. Unser Programm sollte beim Beenden curses vernünftig deaktivieren, weswegen als letzter Aufruf in der <tt>main</tt>-Funktion folgender sein sollte:
<pre> endwin(); </pre>

Wenn die Quelltextdatei ''pong.c'' heißt, kann sie ab jetzt mit folgendem Befehl kompiliert werden:
<pre> gcc -o pong -lcurses pong.c </pre>

=== Variablen für den Zustand des Spiels ===
Zuerst überlegen wir uns, wie groß unser Spielfeld und die Schläger sein sollen. Diese Werte sollten als Define-Makros angegeben werden. Ein kleines, aber feines Feld bekommt man z.B. mit einer Breite von 40, einer Höhe von 15 und einer Schlägerhöhe von 3.

Jetzt führen wir die Variablen ein, die den Spielzustand repräsentieren sollen. Wir brauchen je eine y-Positionen für die beiden Schläger. Dazu kommt x- und y-Position des Balls. Diese Positionsvariablen sind vom Typ <tt>int</tt>. Damit wir wissen, in welche Richtung sich der Ball gerade bewegt, brauchen wir x- und -y-Richtung. Dafür eignet sich auch <tt>int</tt>; welche die Werte 1 und -1 annehmen können sollen, je nachdem, ob es nach rechts/links bzw. nach unten/oben gehen soll. Jetzt brauchen wir noch zwei Variablen für den Punktestand, die wir auch gleich mit 0 initialisieren können.

Die Funktion <tt>void place_paddles()</tt> soll die Schläger mittig platzieren. Die Funktion <tt>void place_ball()</tt> soll den Ball in der Mitte platzieren. Die x- und y-Richtung können wir erstmal mit 1 belegen. Beide Funktionen sollten jetzt in der <tt>main</tt> aufgerufen werden.

=== Ausgeben des Spielfelds ===
Jetzt soll die Funktion <tt>void print_field()</tt> geschrieben werden, die das komplette Spielfeld und den Punktestand anzeigen soll. Schaue dir dazu den obigen Screenshot an und überlege, wie du diesen zeilenweise aus den Positionsvariablen zusammenbauen kannst.

In der Funktion sollte zuerst <tt>clear()</tt> von curses aufgerufen werden, was den bisherigen Terminalinhalt löscht. Wichtig ist, dass du <tt>printw()</tt> von curses statt <tt>printf()</tt> verwendest. Die Art und Weise der Verwendung ist aber identisch. Zum Schluss muss noch <tt>refresh()</tt> von curses aufgerufen werden, damit das eben ausgegebene erscheint.

Teste nun dein <tt>print_field()</tt>, indem du es in <tt>main</tt> aufrufst. Sollte das Bild gleich nach Starten des Programms wieder verschwinden, baue am Ende noch ein <tt>sleep(10)</tt> ein, damit das Programm noch 10 Sekunden läuft.

=== Verarbeiten der Tastendrücke ===
Als nächstes kommt die Funktion <tt>void key_processing()</tt> dran. Darin fragen wir nun folgendermaßen einen Tastedruck ab:
<pre>int ch = getch();</pre>
Wir können das Ergebnis in ''ch'' nun z.B. mit der Konstante <tt>KEY_UP</tt> und <tt>KEY_DOWN</tt> bzw. den Buchstaben <tt>'w'</tt> und <tt>'s'</tt> vergleichen und entsprechend die Positionsvariable der Schläger erhöhen oder veringern. Dabei sollte abgefangen werden, dass der Schläger außerhalb des Spielfelds landet. Wurde keine oder eine ungültige Taste gedrückt, können wir das hier stillschweigend ignorieren.

Zum Testen kann die Funktion zusammen mit <tt>print_field()</tt> und einer 100-Millisekunden-Pause in eine Endlosschleife gepackt werden. Für Pausen eignen sich die Funktionen <tt>sleep</tt> und <tt>usleep</tt> aus ''stdlib.h''. Erstere nimmt Sekunden, letztere Mikrosekunden an. (1 Sekunde = 1.000 Millisekunden = 1.000.000 Mikrosekunden)

=== Ball bewegen ===
Schreibe jetzt die Funktion <tt>void move_ball()</tt>, die die Positionsvariablen des Ball entsprechend der Werte der Richtungsvaraiblen inkrementiert bzw. dekrementiert.

Teste die Funktion, indem du sie in der Test-Endlosschleife aufrufst. Der Ball fliegt jetzt erstmal ziemlich schnell aus dem Spielfeld.

=== Kollisionen des Balls erkennen ===
Die jetzt zu schreibende Funktion <tt>void detect_collision()</tt> soll Kollisionen mit der oberen/unteren Kante und den Schlägern erkennen und den Ball entsprechend reflektieren.

Das lässt sich realisieren, indem man die y-Position mit der oberen und unteren Kantenposition vergleicht und bei Kollision die y-Richtung umkehrt. Bei den Schlägern geht das ähnlich mit der x-Position; hier muss aber noch geprüft werden, ob die y-Koordinate des Schlägers mit der y-Koordinate des Balls zusammenpasst (Schlägerhöhe beachten).

Zum Testen kann die Funktion jetzt wieder in der Endlosschleife aufgerufen werden. Jetzt fliegt der Ball nur noch aus dem Spielfeld, wenn ihn kein Schläger getroffen hat.

=== Erkennen, wenn der Ball nicht vom Schläger getroffen wurde ===
Dazu schreiben wir jetzt die Funktion <tt>int detect_ball_out()</tt>. Der Rückgabewert soll angeben, für welchen Spieler es im weiteren Programmablauf den Punkt geben soll. Die Funktion muss prüfen, ob der Ball in der x-Position auf der Höhe eines Schlägers ist und für die rechte Seite <tt>1</tt> bzw. für die linke Seite <tt>2</tt> zurückgeben. Ansonsten gibt die Funktion <tt>0</tt> zurück.

Getestet werden kann die Funktion jetzt, indem sie als negierte Bedingung für die bisherige Endlosschleife genutzt wird.

=== alles in ein rundenbasiertes Spiel stecken ===
Wir lagern nun die bisherige Testschleife in die neue Funktion <tt>int play_round()</tt> um. Der Rückgabewert soll der Wert sein, den <tt>detect_ball_out()</tt> im Fall des Nichttreffens liefert. Bisher reagieren die Schläger noch recht langsam, weshalb wir die Pause in der Schleife auf 20 Millisekunden herabsetzen. Da nun aber der Ball viel zu schnell wird, sollte <tt>move_ball</tt> nur jeden fünften Schleifendurchlauf aufgerufen werden.

In der <tt>main</tt>-Funktion erstellen wir nun eine Schleife mit der Bedingung, dass beide Spieler noch weniger als 10 Punkte haben. In den Schleifenkörper kommt unser <tt>play_round()</tt>; danach wird abhängig von dessen Ergebnis der Punktestand von Spieler 1 bzw. Spieler 2 inkrementiert. Dann wird der Ball mit <tt>place_ball</tt> neu platziert, bevor die nächste Runde beginnt. Hier ist es sinnvoll, die x-Richtung zum Spieler zu setzen, der zuletzt den Ball nicht getroffen hat (es muss also die Richtung noch an <tt>place_ball</tt> übergeben werden).

Wenn das Spiel zu Ende ist, soll noch ausgegeben werden, welcher Spieler gewonnen hat (wieder <tt>printw()</tt> und <tt>refresh()</tt> verwenden).

=== Zusatzaufgabe: KI ===
Statt des zweiten Spielers soll nun ein Computergegner spielen. Eine einfachste Lösung wäre, in jedem Schritt den die y-Position des Balls mit der des Schlägers zu vergleichen und ihn entsprechend nach oben/unten zu bewegen. Schreibe dazu eine entsprechende Funktion <tt>ai_opponent</tt>. Nun bewegt sich der Schläger genauso schnell, wie der Ball, womit die die KI unbesiegbar ist. Führe deswegen eine Funktion <tt>can_move</tt> ein, von der abhängt, ob sich der Schläger bewegt. Die Funktion sollte mit einer gewissen Wahrscheinlichkeit ''wahr'' zurückliefern. Die Schwierigkeit besteht darin, einen ausgewogenen Gegner zu programmieren. Eine gute Idee ist es z.B., die Position des Balls mit in die Wahrscheinlichkeit einfließen zu lassen.

=== Zusatzaufgabe: andere Winkel des Balls ===
Bisher fliegt der Ball immer im 45°-Winkel. Beim originalen Pong verändert sich der Winkel jedoch bei jedem Aufschlag auf den Schläger zufällig. Man könnte jetzt die Ballpositionen und -richtungen intern als <tt>float</tt> speichern, um andere Winkel zu erreichen.

== Kommentare ==
Wenn du Anmerkungen zur Aufgabe hast oder Lob und Kritik loswerden möchtest, ist hier die richtige Stelle dafür. Klicke einfach ganz rechts auf "bearbeiten" und schreibe deinen Kommentar direkt ins Wiki. Keine Scheu, es geht nichts kaputt ;)



----

Der Befehl gcc -o pong -lcurses pong.c funktioniert nicht. So funktionierts: gcc -o pong pong.c -lcurses

----

Kickerturnier 2013/orga

2013-10-16T14:48:52Z

130.149.245.244: Orga Kickertische einigetragen

== Orga Mitglieder ==
Levi, Jan, Flo, Marcel, Konrad, Carl, Thomas, Till, Thilo, Maggy

==Protokoll - Vorbereitungstreffen 15.10.2013==

====Termin der Veranstaltung====
* Freitag, 22.11.2013

====Uhrzeit====
* 18:00 Uhr

====Raum====
* Raumbuchung ueber TU ueber AStA, ...
** Verantw.: Magdalena und Thomas

====Orga-Kickertische====
* Ausleihen der Kicker anschreiben (Termin Abholung/Abgabe)
** Verantw.: Flo und Levi
* Transport der Kickertische voraussichtlich Ausleihen eines Autos vom AStA
** Verantw.: Marcel, Konrad und Jan

====Medien====
* Musik vom Laptop inkl. Boxen
* Tafel zum notieren der Ergebnisse oder via Beamer
** Verantw.: Konrad; Marcel
* Bearbeitung von ggf. zwei Rechnern

====Anmeldung====
* Anmeldung der Veranstaltung ueber Wiki/Anmeldescript
** Verantw.: Carl
* Siehe Liste 2012

====Zutritt====
* Zutritt zum Gebaeude fuer Aussenstehende
* Liste von Teilnehmern an Pfoertner
** Verantw.: Carl

====Verpflegung====
* Vorzeitige Absprache mit dem Lieferanten bzgl. der voraussichtlichen Menge
* Bevorzugtes Nahrungsmittel: Pizza
* Getraenke absprache mit Freitagsrunde GetraenkeOrga
* Abrechnung schon bei der Bestellung
* Kassenwart
** Verantw.: Thomas

====Regeln====
* siehe Vorjahre
** Verantw.: Konrad und Marcel

====Sieger-Preis-Praemie====
* gebastelte Trophae sh. Ideen der vergangenen Jahre
** Verantw.: Till und Thomas

====Werbung====
* Plakat Gestaltung, Druck
** Verantw.: Jan und Till
* Verteilung durch Alle
* Mailverteiler der Uni
** Verantw.: Levi

====Risiken====
* Veranstaltungstermin abhaengig von der Verfuegbarkeit der Kickertische und Transporter

====Absprachen====
* Mailing Liste wird erstellt
** Verantw.: Magdalena
* E-Mail Adressen wurden festgehalten

====Naechstes Treffen====
* Mittwoch der 23.10.2013 um 18:00 Uhr MAR 0.005

==Ergebnisse der Orga Kickertische==

====Café Erdreich====
*<div style="color:red">Nicht zur Verfügung</div>
**Kicker zu zerbrechlich für den Transport

====Café A====
*<div style="color:green">Zur Verfügung</div>
**Genaueres wird morgen im Gespräch im Café A geklärt

====Café PlanWirtschaft====

====DAI Labor====

====inet====

====swt====

====Kicker von Professor oben im Mar====

C-Kurs/Buchstaben zählen

2013-09-10T09:52:29Z

130.149.245.244: /* Anonym */

== Aufgabenstellung ==

Schreibe ein Programm, das die Vorkommnisse aller Buchstaben in einer Datei zählt und anschließend ausgibt. Dabei sollen Groß- und Kleinbuchstaben zusammengefasst werden. Verwende die folgende Vorgabe:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv) {
if (argc != 2) {
printf("missing filename\n");
return 0;
}

// open file
FILE *file = fopen(argv[1], "r");
if (file == NULL) {
printf("cannot open file\n");
return 0;
}

// TODO your code here

// close the file
fclose(file);
}

== Hinweis zum Dateienlesen ==
Für diese Aufgabe werden folgende File-IO-Funktionen benötigt. Die ersten beiden sind in der Vorgabe schon vorhanden.
* <tt>fopen(filename, "r")</tt> öffnet die Datei unter dem angegebenen Dateinamen im Nur-Lese-Modus und gibt einen FILE-Pointer zurück, mit dem im Folgenden auf die Datei zugegriffen werden kann.
* <tt>fclose(file)</tt> schließt die Datei.
* <tt>fgetc(file)</tt> liest ein Zeichen der Datei. Ist die Datei zuende, gibt die Funktion <tt>-1</tt> zurück.

== Hinweis zum Umgang mit chars ==
Mit <tt>char</tt> kann man genauso rechnen, wie mit <tt>int</tt>. Die Berechnung <tt>character-'a'</tt> ergibt also die Position des Buchstaben im Alphabet, wenn <tt>character</tt> zwischen <tt>a</tt> und <tt>z</tt> in der [http://de.wikipedia.org/wiki/ASCII-Tabelle ASCII-Tabelle] liegt.

== Zusatzaufgabe ==
Verschönere die Ausgabe so, dass für jede Buchstabenhäufigkeit eine visuelle Ausgabe (z.B. in Form eines Balkens aus <tt>#</tt>) angezeigt wird, die den relativen Anteil des Buchstabens darstellt.

== Kommentare ==
Wenn du Anmerkungen zur Aufgabe hast oder Lob und Kritik loswerden möchtest, ist hier die richtige Stelle dafür. Klicke einfach ganz rechts auf "bearbeiten" und schreibe deinen Kommentar direkt ins Wiki. Keine Scheu, es geht nichts kaputt ;)

== Anonym ==
int main(int argc, char **argv) {<br>
Die Argumente von Main und auch die Sternchen sollten erklärt werden. Es kam weder in der 1.VL noch im 1.Tut.

----

das sind die kommandozeilen parameter der ausfuehrbaren datei, wobei argc (Argument Count) die anzahl der uebergebenen argumente ist und argv (Argument Values) die einzelnen uebergebenen argumente sind. hierbei werden argumente unterschieden wenn sie von einem space character (040) getrennt sind.

argc ist hierbei mindestens 1, da es mindetens den namen der ausfuehrbaren datei enthaelt.

andererseits ist es fuer die lsg der aufgabe eher unerheblich was genau in dem vorgegebenen code passiert, desshalb ist er ja vorgegeben und wird nicht vorrausgesetzt...

mfg alex



[[Kategorie:CKurs]]
[[Kategorie:CKurs_Aufgaben]]