FreitagsrundenWiki - Benutzerbeiträge [de]

C-Kurs/Tron

2010-09-20T12:39:25Z

Alexander Kührmann: Formattierung und Rechtschreibung

[[Datei:Tron-screenshot.png|miniatur|300px|So in etwa soll dann unser Spiel aussehen]]Hier wollen wir euch mal ein wenig SDL zeigen - am Beispiel von Tron. SDL steht für "Simple Direct media Layer" und kümmert sich um Tastatureingaben und um ein Zeichenfenster (eigentlich um noch viel mehr, [[#Further_reading_oder_.22Was_kann_SDL_denn_noch.3F.22|siehe unten]]). SDL ist plattformunabhängig; ihr könnt euren Code also sowohl unter Linux als auch unter Windows oder Mac compilen und ausführen.

'''Tron:''' Tron ist ein kleines Spiel für zwei (oder mehr) Spieler, dass ihr vielleicht aus dem Film Tron oder dem Spiel Amagetronad kennt. In unserer Zwei-Spieler-2D-Variante startet jeder Spieler als ein Punkt auf dem Spielfeld. Während des Spieles zieht jeder Spieler eine Linie hinter sich her. Fährt man irgendwo gegen (gegnerische Linie, eigene Linie, Bildschirmrand), so hat man verloren und eine neue Runde beginnt.

Das Ganze machen wir Schritt für Schritt, vom Initialisieren des Fensters über Abarbeiten der Tastatur-Events und Erkennen der Kollisionen bis hin zum Zeichnen des Feldes.
Falls ihr mehr über eine der SDL-Funktionen wissen wollt (also alle Funktionen/Datenstrukturen, die mit SDL_ anfangen), könnt ihr entweder auf http://www.libsdl.org/cgi/docwiki.cgi gucken oder (falls ihr ein Unix-artiges Betriebssystem mit installiertem SDL habt) einfach "man FUNKTION" (z.B. man SDL_Init) in eine Konsole eingeben um Hilfe zu dieser Funktion zu bekommen. Ich werde an entsprechenden Stellen einfach (man funktion) als Hinweis schreiben, dass man mit dieser Funktion noch mehr anstellen könnte.

== Was ihr braucht ==
* SDL mit Development-Headers (unter Debian/Ubuntu heißt das Paket libsdl1.2-dev)
* Die beiden Hilfs-Funktionen um Pixel von zu setzen/lesen (putpixel/getpixel). Diese könnt ihr hier ([http://docs.freitagsrunde.org/Veranstaltungen/ckurs_2010/aufgaben/tron/pixel.h pixel.h]/[http://docs.freitagsrunde.org/Veranstaltungen/ckurs_2010/aufgaben/tron/pixel.c pixel.c]) von uns downloaden oder auch von http://www.libsdl.org/cgi/docwiki.cgi/Pixel_Access .

== Ein erstes Fenster ==
Fangen wir mit unserem Fenster an.

=== SDL initialisieren ===
Zu Beginn müssen wir das SDL Headerfile und unsere pixel.h includen.
<pre>
#include <SDL/SDL.h>
#include "pixel.h"
</pre>

In der Main-Funktion rufen wir zu aller erst die Initialisierungsfunktion von SDL auf:
<pre>
SDL_Init(SDL_INIT_EVERYTHING);
</pre>
Der Einfachheit halber initialisieren wir alles, was SDL zu bieten hat. Man kann ggf. nur Teilsysteme initialisieren (man SDL_Init), das ist für uns aber gerade nicht so wichtig.

Als nächstes müssen wir SDL sagen, dass wir ein Fenster haben wollen und wie groß dieses sein soll. Das machen wir mit der Funktion <tt>SDL_Surface *SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags)</tt>. Wir geben der Funktion die gewünschten Parameter für das Fenster und SDL gibt uns ein <tt>SDL_Surface</tt> (dieser Typ hält in SDL eine Grafik, in diesem Fall unser Fenster).
<pre>
SDL_Surface *screen = SDL_SetVideoMode(640, 480, 32, SDL_SWSURFACE);
</pre>
Oookay.. SDL gibt uns hier ein
* 640 Pixel breites
* 480 Pixel hohes Fenster mit
* 32 Bits pro Pixel (hat was mit der Farbtiefe zu tun, für uns nicht so wichtig, das passt schon so)
* als <tt>SDL_SW_SURFACE</tt> (soll heißen wir benutzen keine Hardwarebeschleunigung)
Für den letzten Parameter, also die Window Flags, gibt es viele verschiedene Parameter (man SDL_VideoMode), die man einfach miteinaner verunden könnte (z.B. <tt>SDL_HWSURFACE | SDL_FULLSCREEN</tt> für Vollbild mit Hardwarebeschleunigung), aber auch das ist für uns gerade nicht wichtig.

Zu guter letzt rufen wir am Ende der main-Funktion noch ein <tt>SDL_Quit()</tt> auf, damit SDL sich deinitialisiert, wenn wir das Programm beenden.

Nun wollen wir unser Grundgerüst ausprobieren. Damit, wenn wir das Programm starten, das Fenster nicht sofort wieder zu geht packen wir hinter die Initialisierung (aber vor das <tt>SDL_Quit()</tt>) ein <tt>SDL_Delay(5000)</tt> (''SDL_Delay'' nimmt die Zeit in Millisekunden, d.h. der Aufruf wartet 5 Sekunden). Und nun compilen und ausprobieren!
<pre>
gcc -Wall tron.c pixel.c -lSDL -o tron
</pre>

Falls ihr (wie ich) zu faul seid das jedes mal einzugeben könnt ihr auch folgendes Makefile benutzen (soll heißen in die Datei Makefile pasten) und dann nur noch make bzw. make run eingeben.
<pre>
CFLAGS=`sdl-config --cflags` -Wall
LDFLAGS=`sdl-config --libs`
OBJ=tron.o pixel.c

.PHONY: clean run

tron: $(OBJ)

run: tron
./tron

clean:
rm -f *.o tron
</pre>

Jetzt solltet ihr für 5 Sekunden ein Fenster sehen, welches sich dann wieder schliesst.

=== SDL Events ===
Ein sich nach einiger Zeit wieder schliessendes Fenster bringt uns natürlich nicht so viel. Was wir wollen ist mit SDL zu interagieren. Wir wollen wissen, ob jemand eine Taste auf der Tastatur gedrückt hat oder das Fenster schliessen wollte. All das sagt uns SDL mit sog. '''Events'''. Davon gibt es viele für alle möglichen Gegebenheiten (man SDL_Event), aber wir wollen als erstes nur den Fall des sich schliessenden Fensters betrachten.

Als erstes brauchen wir eine Variable vom Typ <tt>SDL_Event</tt> in der wir das Event speichern. Um SDL nach einem Event zu fragen übergeben wir <tt>int SDL_PollEvent(SDL_Event*)</tt> eine Referenz zu dieser Variable.
<pre>
SDL_Event event;
SDL_PollEvent(&event);
</pre>
<tt>SDL_PollEvent</tt> hat als Rückgabewert 1, wenn es ein Event gefunden hat und 0, falls es kein neues Event gab. <tt>SDL_Event event</tt> ist ein struct, in <tt>event.type</tt> steht der Typ des aktuellen Events. Für unser Spiel sind folgende Events wichtig (Dies sind dann auch die Werte, welche in <tt>event.type</tt> stehen): SDL_QUIT falls das Programm beendet werden soll und SDL_KEYDOWN, falls eine Taste auf der Tastatur gedrückt wurde.

Schreibt nun in die main-Funktion eine while-Schleife. In dieser Schleife sollen SDL-Events abgefragt werden (unser sog. Event-Loop). Wenn ein SDL_QUIT-Event auftritt soll das Programm beendet werden. Damit die while-Schleife nicht all eure CPU-Zeit frisst solltet ihr mit <tt>SDL_Delay</tt> eine Verzögerung von 10-50 Millisekunden einbauen.

Nun kann man das Fenster über das ihm gegebene X (bei entsprechendem Windowmanager *hust*) schließen. Horray, unser Fenster hört auf uns!

== Tron ==

=== Zustandsvariablen ===
Es wird Zeit, dass wir zu unserem Spiel kommen. Ein Spieler in Tron hat in etwa folgende Eigenschaften:
* eine Position (x/y)
* eine Richtung (up, down, left, right)
* Punktestand
* Farbe des Spielers (Definiert als Rot/Grün/Blau-Wert von 0-255)
Für Position und Punke können wir jeweils den Typ int wählen. Für die Farbe nehmen wir <tt>SDL_Color</tt> (das ist ein von SDL definiertes struct mit drei Uint8 r, g und b für den Farbwert rot, grün und blau (man SDL_Color)). Bei der Richtung könnt ihr euch überlegen, ob ihr lieber ein '''enum''' nehmen wollt anstatt eines ints. Wir packen diese Werte in ein struct Player, damit wir später Funktionen nur einmal schreiben müssen und dann für jeden Spieler jeweils einmal aufrufen können.

Schreibt nun eine Funktion <tt>void initPlayers()</tt>, welche die Variablen der beiden Spieler initialisiert (und ihnen auch eine schöne Farbe gibt ;). Die Startposition der Spieler machen wir abhängig von der Spielfeldgröße. Ich schlage halbe Höhe des Feldes als Y-Koordinate und 1/3 bzw. 2/3 der Breite als Startposition vor. Hier ein Codeschnipsel, wie ihr an das <tt>SDL_Surface</tt> vom Fenster und an dessen Höhe/Breite kommt:

<pre>
[...]
SDL_Surface *screen = SDL_GetVideoSurface();
int hoehe = screen->h;
int breite = screen->w;
</pre>
Der Rückgabewert von <tt>SDL_GetVideoSurface</tt> ist hierbei mit dem von <tt>SDL_SetVideoMode</tt> identisch (halt der Zeichenbereich unseres Fensters).

Ruft nun <tt>initPlayers()</tt> in eurer main-Funktion nach dem Initialisieren von SDL auf (sonst ist der Rückgabewert von <tt>SDL_GetVideoSurface()</tt> nicht definiert und ihr habt keine Fensterhöhe/breite).

=== Zeichnen der Spieler ===
Nun wollen wir anfangen unsere beiden Spieler zu zeichnen und sich bewegen zu lassen. Dazu setzen wir den Pixel, auf dem der Spieler sich gerade befindet auf seine Farbe.
<pre>
putpixel(SDL_Surface *screen, int x, int y, Uint32 pixel);
</pre>

Da <tt>putpixel</tt> einen <tt>Uint32</tt> als Farbwert erwartet müssen wir unser <tt>SDL_Color</tt> wohl umwandeln. Dies passiert mit der Funktion
<pre>
Uint32 SDL_MapRGB(SDL_PixelFormat *fmt, Uint8 r, Uint8 g, Uint8 b);
</pre>
wobei mit <tt>SDL_PixelFormat</tt> das PixelFormat unseres screens gemeint ist (screen->format (man SDL_Surface)).

* Schreibt eine Funktion <tt>Uint32 color2rgb(SDL_Color)</tt> welche ein <tt>SDL_Color</tt> in den entsprechenden <tt>Uint32</tt> umwandelt.
* Schreibt eine Funktion <tt>void paintPlayer(struct Player*)</tt> welche einen Spieler zeichnet.

Wichtig: Eure Zeichenoperationen (also alles, was etwas in das Fenster bringt) werden erst sichtbar, wenn ihr SDL sagt, dass ihr eure "Änderungen" sehen wollt. Der Einfachheit halber benutzt nach euren Zeichenoperationen <tt>int SDL_Flip(screen)</tt> (wobei screen unser Fenster (SDL_Surface*) ist) um dies zu tun (wer hier mehr drüber wissen will kann sich mal <tt>SDL_UpdateRect</tt> anschauen).

Nun zeichnet in eurer main-Funktion vor dem Event-Loop die beiden Spieler und startet das Programm. Jetzt können wir unsere beiden Spieler als Pixel sehen.

=== Bewegen der Spieler ===
Ohne Bewegung wird das alles auf Dauer ziemlich langweilig. Deshalb brauchen wir eine Funktion <tt>void movePlayer(struct Player*)</tt>, welche abhängig von der Richtung des Spielers dessen Position verändert. Diese Funktion müssen wir nun in unserer Event-Loop unterbringen. Wenn wir kein Event haben, dann wollen wir unsere Spieler beide bewegen (<tt>movePlayer</tt>), beide zeichnen (<tt>paintPlayer</tt>), unseren Bildschirm aktualisieren (<tt>SDL_Flip</tt>) und dann ein wenig warten (<tt>SDL_Delay</tt>).

Wenn das fertig ist und wir unser Programm starten, dann sehen wir, dass beide Spieler sich in ihre Richtung bewegen und sich ggf. übermalen. Sobald aber einer aus dem Bildschirm verschwindet passieren komische Sachen: Entweder sie kommen auf der anderen Seite wieder raus oder unser Programm stürzt ab. Hmmmm, da fehlt uns wohl...

=== Kollisionen erkennen und behandeln ===
In unserem Spiel gibt es drei Arten von Kollision
* Ein Spieler fährt aus dem Fenster raus
* Ein Spieler fährt gegen eine Linie (eine eigene oder eines Gegners)
* Beide Spieler befinden sich auf der gleichen Position (unentschieden!)

Die ersten beiden Fälle wollen wir mit der Funktion behandeln <tt>int playerCollided(struct Player*)</tt>. Sie soll überprüfen, ob der Spieler in seiner aktuellen Position ausserhalb des Bildschirms ist oder ob dort schon einer vor ihm war. Letzteres könnt ihr leicht überprüfen, indem ihr guckt, ob an dieser Stelle ein schwarzer Pixel ist (soll heißen: leeres Spielfeld). Das könnt ihr überprüfen, indem ihr schaut, ob der Wert, den <tt>Uint32 getpixel(SDL_Surface *screen, int x, inty)</tt> zurückliefert dem entspricht, was <tt>SDL_MapRGB</tt> für Schwarz (0, 0, 0) zurückgibt. Die Funktion soll 1 für Kollision und 0 für keine Kollision zurückgeben.

Nun brauchen wir die Funktion <tt>int gotCollison()</tt> welche 0 für keine Kollision, 1 für Player1 kollidiert, 2 für Player2 kollidiert und 3 für Unentschieden zurückgibt. Benutzt hierzu <tt>playerCollided()</tt> um herauszufinden, ob ein Spieler kollidiert ist und implementiert ausserdem den 3. Fall.

Aber was machen wir, wenn wir eine Kollision erkannt haben? Wir setzen alles wieder auf den Startzustand. Also brauchen wir eine Funktion <tt>void resetGame()</tt>, die
* unser Fenster komplett schwärzt (uns von den alten Linien befreit)
* die Spieler auf ihre Startpositionen setzt (Richtung nicht vergessen!)
* die beiden Spieler zeichnet

Zum Schwärzen des Bildschirms könnt ihr <tt>SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0))</tt> benutzen (man SDL_FillRect). <tt>NULL</tt> steht hierbei für das zu füllende Rechteck - wir übergeben keines, denn dadurch wird automatisch der gesamte Bildschirm angenommen.

Nun kombinieren wir all diese schönen Funktionen miteinander in unserer Event-Loop in unserer main-Funktion:
* Fortbewegen beider Spieler
* Überprüfen, ob eine Kollision stattfand
** Wenn ja: Dem jeweiligen Spieler, der nicht kollidiert ist, einen Punkt geben und das Spielfeld resetten
** Wenn nicht: Beide Spieler auf ihrer neuen Position zeichnen
* Den Bildschirm updaten ("flippen")

Puh! Nun haben wir es aber auch schon fast geschafft. Fehlt nur noch die Bewegung der Spieler und eine Punkteanzeige.

=== Tastatureingaben zu Richtungswechsel ===
Um die Richtung eines Spielers zu wechseln müssen wir ihm eigentlich nur einen anderen Wert in seine Richtungsvariable schreiben. Den Rest macht dann schon unsere <tt>movePlayer</tt>-Funktion in der Event-Loop. Aber wie kriegen wir raus, welche Taste gedrückt wurde? Genau, per Event. Momentan dümpelt in unserer Event-Abfrage nur unser <tt>SDL_QUIT</tt>-Event rum. Nun wollen wir ausserdem gucken, ob es sich nich doch um ein <tt>SDL_KEYDOWN</tt>-Event handelt. Wenn es eines ist (<tt>event.type == SDL_KEYDOWN</tt>, schon vergessen?), steht in <tt>event.key.keysym.sym</tt> die Taste, die gedrückt wurde. <tt>sym</tt> ist vom Typ <tt>SDLKey</tt>. Alle benutzbaren Tasten findet ihr unter (man SDLKey), aber momentan sollten <tt>SDLK_LEFT</tt>, <tt>SDLK_RIGHT</tt>, <tt>SDLK_UP</tt>, <tt>SDLK_DOWN</tt>, <tt>SDLK_a</tt>, <tt>SDLK_w</tt>, <tt>SDLK_s</tt> und <tt>SDLK_d</tt> reichen.

Also: Behandelt das <tt>SDL_KEYDOWN</tt>-Event, schaut ob eine Taste für einen der Spieler gedrückt wurde und behandelt diese. Wenn ihr das Spiel etwas einfacher machen wollt, dann passt auf, das kein Spieler in sich selbst steuern kann (d.h. keine 180° Wendung, also z.B. von left zu right wechseln).

Tja, nun habt ihr ein spielbares (und plattformunabhängiges) Multiplayer 2D Tron Spiel!

=== Punkte? ===
Naja gut, was noch fehlt ist eine Punkteanzeige. Die realisieren wir ganz einfach über unseren Fenstertitel. Den kann man mit
<pre>
SDL_WM_SetCaption("Mein tolles Fenster!1!!", 0);
</pre>
setzen.

Schreibt eine Funktion <tt>void updateWindowTitle()</tt> welche (z.B. mit <tt>sprintf</tt>) einen Titel für das Fenster (z.B. C-Kurs Tron) und dahinter den aktuellen Punktestand zusammensetzt und unserem Fenster diesen gibt. Diese Funktion muss immer aufgerufen werden, wenn sich der Punktestand verändert (und natürlich auch einmal am Anfang). Sucht euch einen schönen Platz dafür aus.

== Bonusrunde ==
Wer jetzt noch nicht genug hat...

=== Einsteiger-Bonus: Quit on Esc ===
Das Spiel soll sich beenden, wenn jemand Escape drückt.

=== Bonus: Fenster resizen ===
Macht das Fenster vergrößerbar bzw. verkleinerbar! Denkt dran, dass bei einer neuen Runde die Spieler auch an der richtigen Stelle anfangen (falls ihr diese Werte direkt als Zahlen reingeschrieben habt).

=== Bonus: Ein Torus als Spielfeld ===
Warum sollte man an der Spielwand crashen? Man könnte doch an der jeweils anderen Seite des Feldes herauskommen...

=== Bonus Bonus: Massive Multiplayer ===
Baut das Spiel so um, dass man beim Starten auf der Kommandozeile eine Spielerzahl übergeben kann (z.B. 2-4 Spieler). Damit es nich zu eng auf der Tastatur wird könnte es nützlich sein, wenn ihr das Spiel so umschreibt, dass man nur noch zwei Tasten für Links/Rechts hat um den Spieler zu kontrollieren (Megabonus: Ausser ihr baut Maus+Joysticksupport ein).

== Further reading oder "Was kann SDL denn noch?" ==
SDL hat noch einige interessante Zusatzmodule
* SDL_Image - Kann ein haufen Bildformate laden und in ein SDL_Surface packen (von sich aus kann SDL nur .bmp)
* SDL_Mixer - SDL Soundausgabe
* SDL_Net - SDL Netzwerkbibliothek
Ausserdem kann SDL ziemlich einfach geladene Bilder auf den Bildschirm bringen (man SDL_BlitSurface), Tastatur/Maus/Joystick eingabe behandeln, Musik/Soundeffekte zusammenmixen oder auch (mit der entsprechenden Bibliothek) Netzwerkkram machen. Gerne wird es für 2D Spiele benutzt (z.B. supertux, xmame, frozen-bubbles, ...), aber auch als Wrapper für OpenGL (sauerbraten, der Quake3 Linux Port, warsow, armagetronad...); teilweise nutzen auch einige Anwendungen SDL (mplayer, virtualbox, dosbox, ...).

Einsteigerfreundliche SDL-Tutorials:
* http://www.lazyfoo.net/SDL_tutorials/index.php
* http://www.libsdl.org/cgi/docwiki.cgi/
* http://www.libsdl.org/cgi/docwiki.cgi/Using_OpenGL_With_SDL

Happy Hacking ;)

C-Kurs/Übungsaufgaben

2010-09-20T10:23:38Z

Alexander Kührmann: /* Die Aufgaben */ Musterlösung für DTMF hinzu

Wir haben jeder Aufgabe eine Einschätzung ihrer Schwierigkeit auf einer Skala von 1 bis 10 vorangestellt. Bei dieser Einschätzung sind wir von einem Gehirn ausgegangen, für welches das jeweilige Themengebiet völlig neu ist, das jedoch schon ein ganz gutes Verständnis dafür hat wie eine Programmiersprache denn so funktioniert.
Entsprechend kann eine schwer bewertete Aufgabe aus einem frühen Themengebiet für manch einen sehr einfach oder eine leicht bewertete aus einem späten Themengebiet für einen anderen sehr schwer sein. Es ist nur ein Wert, der euch helfen soll eure nächste Aufgabe zu wählen.

Falls ihr Anmerkungen zu den Aufgaben habt, könnt ihr die Diskussionsseiten der jeweiligen Aufgaben nutzen.

== Schwierigkeitsgrade ==

# Reines Tutorial. Man muss nicht viel selbst denken
# ...
# Leichte Übungsaufgabe. Studies, die noch eher unsicher sind werden hier gut begleitet.
# ...
# Typische Aufgabe. Man muss den Kopf benutzen, bekommt an schwierigen Stellen aber Hilfestellungen.
# ...
# Herausfordernd, eher etwas für Studies die etwas fitter sind.
# ...
# Auch erfahrene Programmierer werden hier ein bis zwei Übungen beschäftigt sein 
# Tja, die Idee war da. Wir finden sie auch gut, aber es könnte wirklich anstrengend werden.

== Die Aufgaben ==

{| class="wikitable sortable" border="0" cellpadding="4" cellspacing="2"}

|- bgcolor="#D8D8D8"
!Aufgabe
!Schwierigkeit
!Vorwissen
!Lerneffekte
!Bearbeiter
!Korrektur gelesen
!Musterlösung
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Von der Konsole zum HelloWorld | Von der Konsole zum HelloWorld]]
| align="center" |1
| align="center" |1. VL
| Konsole benutzen, Hello World
| Sebastian D.
| [[Benutzer:Mario|Mario]] (2009),
|
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Fakultät | Fakultät]]
| align="center" |2
| align="center" |1. VL
| Schleifen
| Sebastian D.
| Daniel (2009),
|
|- bgcolor="#F5F5F5"
| [[Ckurs2010/Pythagoras-Triplet | Pythagoras-Triplet]]
| align="center" |2
| align="center" |1. VL
| Schleifen if-Bedingungen
| Gabriel P.
| seba(2010)
| [[Ckurs2010/Pythagoras-Triplet/Musterloesung | Pythagoras-Triplet]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Fibonacci-Folge|Fibonacci-Folge]]
| align="center" |2
| align="center" |1. VL
| Funktionen Rekursion
| Paul B.
| [[Benutzer:Mario|Mario]] (2010)
| [[Ckurs2009/Fibonacci-Folge/Musterlösung | Fibonacci-Folge]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/digitalesSchloesserKnacken|digitales Schloesser knacken]]
| align="center" |4
| align="center" |1. VL
| Kontrollstrukturen Bitweise Operatoren
| Paul B.
| Eugen R. (2010)
| [[Ckurs2009/digitalesSchloesserKnacken/Musterlösung | digitales Schloesser knacken]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Rekursives_arbeiten|Rekursives Arbeiten]]
| align="center" |3-5
| align="center" |1. VL
| Bekannte Operatoren wie + durch Funktionen succ und neg nachbilden
| Eugen R.
| Paul B.(2010)
| [[Ckurs2009/Rekursives_arbeiten/Musterlösung | Rekursives Arbeiten]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Base64 | Base64]]
| align="center" |6
| align="center" |1. VL
| Operatoren
| Sebastian D.
| Paul B.(2010)
| [[Ckurs2009/Base64/Musterlösung | Base64]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/EingabeAusgabe | Ein- und Ausgabe]]
| align="center" |1
| align="center" |2. VL
| Einlesen von Benutzereingaben Ausgabe derselben
| [[Benutzer:Mario|Mario]]
| nion (2009),
| [[Ckurs2009/EingabeAusgabe/Musterlösung | Ein- und Ausgabe]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Taschenrechner | Taschenrechner]]
| align="center" |3
| align="center" |2. VL
| Eingabe+Ausgabe Mathematische Operatoren
| [[Benutzer:Mario|Mario]]
| [[Benutzer:Tkroenert|TKroenert]] (2009),
| [[Ckurs2009/Taschenrechner/Musterlösung | Taschenrechner]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/VerschachtelteSchleifen | Verschachtelte Schleifen]]
| align="center" |3
| align="center" |2. VL
| Umgang mit mehreren verschachtelten Schleifen
| [[Benutzer:Dank|Daniel K.]]
| AlexanderK (2009),
|
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Glückspiel | Glücksspiel]]
| align="center" |3
| align="center" |2. VL
| Anwenden von Fallunterscheidungen und Einlesen von Werten aus der Konsole
| [[Benutzer:Dank|Daniel K.]]
| AlexanderK (2009),
| [[Ckurs2009/Glückspiel/Musterlösung | Glückspiel]]
|- bgcolor="#E8E8E8"
| [[Ckurs/Buchstaben_zählen | Buchstaben zählen]]
| align="center" |4
| align="center" |2. VL
| Array, Dateien lesen
| Alex K.
| Gabriel (2010)
| vorhanden bitte reinstellen
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Wochentag | Wochentagsrechnung]]
| align="center" |5
| align="center" |2. VL
| Einlesen von Benutzereingaben Mathematikverständniss
| [[Benutzer:Mario|Mario]]
| nion (Musterlösung noch nicht vorhanden) (2009),
|
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Taschenrechner2.0 | Taschenrechner ''2.0'']]
| align="center" |8
| align="center" |2. VL
| Knobeln Komplexes Aufgaben lösen
| [[Benutzer:Mario|Mario]]
| Martin K. (2009),
| [[Ckurs2009/Taschenrechner2.0/Musterlösung | Taschenrechner ''2.0'']]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Call by reference | Call by reference]]
| align="center" |4
| align="center" |3. VL
| Einfache Anwendung von &/*
| sping
| nion (2009), Alex K. (2010)
| [[Ckurs2009/Call by reference/Musterlösung | Call by reference]]
|- bgcolor="#F5F5F5"
| [[Ckurs2010/String to Double | String to Double]]
| align="center" |5
| align="center" |3. VL
| Original-Dokumentation anwenden (Opengroup, man pages) Pointer auf Pointer Const correctness Strings
| sping
| Eugen R. (2010)
| vorhanden bitte reinstellen
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Text processing | Text processing]]
| align="center" |4, 6
| align="center" |3. VL
| Strings Pointer-Arithmetik Pointer auf Pointer Refactoring
| sping
| [[Benutzer:Mario|Mario]] (2009),
| [[Ckurs2009/Text processing/Musterlösung | Text processing]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Palindrome | Palindrome]]
| align="center" |4
| align="center" |3. VL
| Pointer und Strings
| [[Benutzer:Dank|Daniel K.]]
| nion (2009),
| [[Ckurs2009/Palindrome/Musterlösung | Palindrome ]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/(Pointer) Swapping | (Pointer) Swapping]]
| align="center" |5
| align="center" |3. VL
| Pointer und Arrays benutzen, generisches swap
| Katrin
| Katrin (2010)
| [[Ckurs2009/(Pointer) Swapping/Musterlösung | (Pointer) Swapping]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Matrizenmultiplikation | Matrizenmultiplikation]]
| align="center" |6
| align="center" |3. VL
| Mehrdimensionale Arrays const correctness
| sping
| [[Benutzer:Mario|Mario]] (2009),
| [[Ckurs2009/Matrizenmultiplikation/Musterlösung | Matrizenmultiplikation]]
|- bgcolor="#F5F5F5"
| [[Ckurs/DreiD | 3D mit C]]
| align="center" |6-9
| align="center" |3. VL
| Mathematische Rechenoperationen, Algorithmik
| AndreasF
| Mario (2010)
| [[Ckurs/DreiD/Musterloesung | 3D]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Arrayuebergabe | Arrayuebergabe]]
| align="center" |4/5
| align="center" |4. VL
| Einlesen von Benutzereingaben Pointer und Pointerarithmetik
| nion
| Martin K. (2009),
| [[Ckurs2009/Arrayuebergabe/Musterlösung | Arrayuebergabe]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Studentendatenbank | Studentendatenbank]]
| align="center" |4
| align="center" |4. VL
| struct, Pointer, Arrays
| AlexanderK
| Gabriel (2010)
| [[Ckurs2009/Studentendatenbank/Musterlösung | Studentendatenbank]]
|- bgcolor="#E8E8E8"
| [[Ckurs2010/Punktstrukturen| Punktstrukturen]]
| align="center" |2-3
| align="center" |4. VL
| Structs, Unions, Pointer
| [[Benutzer:Mutax|Florian]] (2010)
| Alex K. (2010)
|
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Sammelbestellung | Sammelbestellung]]
| align="center" |2-5
| align="center" |4. VL
| Listen, Pointer, Speicherverwaltung
| [[Benutzer:Mutax|Florian]]
| [[Benutzer:Mario|Mario]] (2009),
| [[Ckurs2009/Sammelbestellung/Musterlösung | Sammelbestellung]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Zahlen_sagen | Zahlen sagen]]
| align="center" |5
| align="center" |4. VL
| Umgang mit Zeichenketten
| Martin K.
| Paul B. (w.i.p.)
|- bgcolor="#E8E8E8"
| [[Ckurs/DTMF-Encoder | DTMF-Encoder]]
| align="center" |8
| align="center" |4. VL
| Pointer, Arrays, Umgang mit Audiodaten
| Alexander K.
|
| [[Ckurs/DTMF-Encoder/Musterlösung | DTMF-Encoder]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Compiler, Präprozessor, Header Files | Compiler, Präprozessor, Header Files]]
| align="center" |3
| align="center" |5. VL
| Arbeiten mit mehreren Quellcode-Dateien, Kompilieren und Linken, Header-Dateien und #include, debugging-Makro verwenden
| Katrin
| AndyF (2010)
| [https://wiki.freitagsrunde.org/Ckurs2009/Vortrag05 siehe Folien]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Bus Error | Bus Error]]
| align="center" |8
| align="center" |5. VL
| Pointer, wie entsteht ein bus error
| Katrin
| [[Benutzer:Mario|Mario]] (2010)
| [[Ckurs2009/Bus Error/Musterlösung | Bus Error]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/BubbleSortDebug | BubbleSort Debugging]]
| align="center" |5
| align="center" |6. VL
| Debuggen eines Programmes mit gdb
| aeichner
|
| [[Ckurs2009/BubbleSortDebug/Musterlösung | BubbleSort Debugging]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Debug | Debugging]]
| align="center" |1-8
| align="center" |6. VL
| Debuggen einer Anwendung nach Wahl
| aeichner
|
|
|- bgcolor="greenyellow"
| [[Ckurs/ckdu | CKDU]]
| align="center" |3-10
| align="center" |7. VL
| '''Vorlesungsaufgabe der 7. Vorlesung'''
| Sping
| [[Benutzer:Tkroenert|TKroenert]] (2010)
|
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Code Layout | Code Layout]]
| align="center" |3
| align="center" |7. VL
| Kleinere Codeschipsel mit kleinen Unsauberkeiten
| Daniel
| [[Benutzer:Tkroenert|TKroenert]] (2010)
| 
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Refactoring | Refactoring]]
| align="center" |5-9
| align="center" |7. VL
| Wie verbessere ich den Quellcode eines Programmes.
| Daniel
|
| 
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Cat | Cat]]
| align="center" |6
| align="center" |2. VL
| Arbeiten mit Dateien Kommandozeilenparameter
| nion
| sping (2009),
| 
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Pong | Pong]]
| align="center" |7
| align="center" |9.VL (eigentlich 2.VL)
| allgemeiner Programmablauf, fortgeschrittene Konsolenausgaben/eingaben
| AlexanderK
| seba(2010)
| 
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Buchhaltung | Buchhaltung]]
| align="center" |6
| align="center" |5.VL
| Lesen aus Dateien
| reiner
| AndyF (2010)
|
|- bgcolor="#E8E8E8"
| [[Ckurs2009/StringArraySortieren | StringArraySortieren]]
| align="center" |5
| align="center" |3. VL
| Konsolparameter, Funktionspointer
| reiner
| martin (2010)
| 
|- bgcolor="#F5F5F5"
| [[Ckurs/integral | integral]]
| align="center" |2
| align="center" |3. VL
| Funktionspointer
| reiner
| [[Benutzer:Tkroenert|TKroenert]] (2010)
| 
|- bgcolor="#E8E8E8"
| [[Ckurs/forschleife | forschleife]]
| align="center" |3
| align="center" |6. VL
| Bug (zum Knobeln)
| reiner
| nion (2009), [[Benutzer:Tkroenert|TKroenert]] (2010)
| 
|- bgcolor="#F5F5F5"
| [[Ckurs/libgdsl | GDSL]]
| align="center" |5-7
| align="center" |9. VL
| Anwendung der Generic Data Structures Library
| martin
|
|
|- bgcolor="#E8E8E8"
| [[Ckurs2009/StdLib | Standard C Library]]
| align="center" |3
| align="center" |9. VL
| Recherche in der Standard C Bibliothek
| martin
|
|
|- bgcolor="#F5F5F5"
| [[Ckurs/Tron | Tron]]
| align="center" |7-9
| align="center" |4. VL
| SDL (Simple Directmedia Layer) kennen lernen, graphische Ausgabe
| seba
|
| 
|- bgcolor="#E8E8E8"
| [[Ckurs2010/TicTacToe | TicTacToe]]
| align="center" |5-7
| align="center" |9. VL
| SDL (Simple Directmedia Layer) kennen lernen, graphische Ausgabe
| Martin
| sdyroff (2010)
| 
|}

== Kleine und große Probleme ==

* Die Tubit-Accounts haben nicht /bin/bash als shell, so dass die Cursortasten nicht funktionieren. Workaround: als erstes Kommando 'bash' eingeben, man sieht dann auch in welchem Verzeichnis man gerade ist.
* wenn man nur den Promt 'bash-0.12' oder so erhält, also ohne das Verzeichnis in dem man ist, folgendes Kommando eingeben: <tt>export PS1='\u@\h:\w$ '</tt> oder zum dauerhaften Speichern: <tt> echo "export PS1='\u@\h:\w$ '" >> ~/.bashrc </tt>

== Musterlösungen ==
Die Lösungen zu den Aufgaben werden nach den jeweiligen Übungen hier veröffentlicht. Falls dies nicht geschieht, bitte den zuständigen Tutor fragen.

== Links ==

* [[Ckurs2009/Feedback|Feedback zum Kurs 2009]]

[[Kategorie:CKurs]]
[[Kategorie:CKurs Aufgaben]]

C-Kurs/DTMF-Encoder/Musterlösung

2010-09-20T10:22:23Z

Alexander Kührmann: Die Seite wurde neu angelegt: „<pre> #include <stdlib.h> #include <stdio.h> #include <math.h> unsigned char* generateSine(int ms, int freq, float amplitude, int *numSamples) { /* calculate...“

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

unsigned char* generateSine(int ms, int freq, float amplitude, int *numSamples) {
/* calculate number of samples and factor for the sine function */
*numSamples = ms * 8; // 8000 Hz sampling rate means 8 samples per millisecond
double numPeriodic = 8000.0 / freq;
double sinFac = 2 * M_PI / numPeriodic;

unsigned char *sine = malloc(*numSamples * sizeof(unsigned char));

/* generate samples */
int i;
for (i = 0; i < *numSamples; i++) {
double sineVal = sin(i * sinFac); // between -1 and 1
unsigned char sample = (unsigned char) ((amplitude * sineVal + 1) * 0x7f);
sine[i] = sample;
}

return sine;
}

unsigned char* mixPcm(unsigned char *a, unsigned char *b, int numSamples) {
unsigned char *result = malloc(numSamples * sizeof(unsigned char));
int i;
for (i = 0; i < numSamples; i++) {
int aVal = a[i] - 127;
int bVal = b[i] - 127;
int rVal = aVal + bVal;
result[i] = (unsigned char)(rVal + 127);
}
return result;
}

unsigned char* generateDtmfTone(int number, int ms, int *numSamples) {
unsigned char *a;
unsigned char *b;
unsigned char *result;
switch (number) {
case 0:
a = generateSine(ms, 941, 0.45, numSamples);
b = generateSine(ms, 1336, 0.45, numSamples);
break;
case 1:
a = generateSine(ms, 697, 0.45, numSamples);
b = generateSine(ms, 1209, 0.45, numSamples);
break;
case 2:
a = generateSine(ms, 697, 0.45, numSamples);
b = generateSine(ms, 1336, 0.45, numSamples);
break;
case 3:
a = generateSine(ms, 697, 0.45, numSamples);
b = generateSine(ms, 1477, 0.45, numSamples);
break;
case 4:
a = generateSine(ms, 770, 0.45, numSamples);
b = generateSine(ms, 1209, 0.45, numSamples);
break;
case 5:
a = generateSine(ms, 770, 0.45, numSamples);
b = generateSine(ms, 1336, 0.45, numSamples);
break;
case 6:
a = generateSine(ms, 770, 0.45, numSamples);
b = generateSine(ms, 1477, 0.45, numSamples);
break;
case 7:
a = generateSine(ms, 852, 0.45, numSamples);
b = generateSine(ms, 1209, 0.45, numSamples);
break;
case 8:
a = generateSine(ms, 852, 0.45, numSamples);
b = generateSine(ms, 1336, 0.45, numSamples);
break;
case 9:
a = generateSine(ms, 852, 0.45, numSamples);
b = generateSine(ms, 1477, 0.45, numSamples);
break;
}
result = mixPcm(a, b, *numSamples);
free(a);
free(b);
return result;
}

unsigned char *generateSilence(int ms, int *numSamples) {
*numSamples = ms * 8; // 8000 Hz sampling rate means 8 samples per millisecond
unsigned char *result = malloc(*numSamples * sizeof(unsigned char));
int i;
for (i = 0; i < *numSamples; i++) {
result[i] = 127;
}
return result;
}

int main(int argc, char **argv) {
if (argc != 2) {
fprintf(stderr, "no number given\n");
return 0;
}

int number;
if (1 != sscanf(argv[1], "%u", &number)) {
fprintf(stderr, "given argument is not a number\n");
return 0;
}

FILE *f = fopen(argv[1], "w");

char *curNum = argv[1];
while (*curNum != '\0') {
int digit = *curNum++ - '0';

int numSamples;
unsigned char *tone = generateDtmfTone(digit, 800, &numSamples);
fwrite(tone, sizeof(unsigned char), numSamples, f);
free(tone);
tone = generateSilence(300, &numSamples);
fwrite(tone, sizeof(unsigned char), numSamples, f);
free(tone);
}

fclose(f);
}
</pre>

C-Kurs/DTMF-Encoder

2010-09-16T16:01:57Z

Alexander Kührmann: /* Sinuswellen generieren */

In dieser Aufgabe soll ein Generator für DTMF-Töne erstellt werden. DTMF steht für Dual-tone multi-frequency und ist auch als [http://de.wikipedia.org/wiki/Mehrfrequenzwahlverfahren Mehrfrequenzwahlverfahren] bekannt.

Wenn du diese Aufgabe in den Rechnerräumen bearbeitest, benutze bei dem Abspielen der Töne bitte Kopfhörer, um andere nicht zu stören.

=== Was ist DTMF? ===
Kurz gesagt: ein DTMF-Ton besteht aus zwei überlagerten Sinuswellen. Für jede Taste auf dem Telefon ist eine bestimmte Frequenzkombination dieser beiden Wellen festgelegt. Genaueres sowie die Frequenzen für die Tasten finden sich [http://de.wikipedia.org/wiki/Mehrfrequenzwahlverfahren hier].

=== Wie werden Töne im Rechner dargestellt? ===
Töne lassen sich als [http://de.wikipedia.org/wiki/Puls-Code-Modulation PCM]-Daten speichnern. Unser Programm soll solche PCM-Daten generieren. Ausreichend sind hier 8 Bit pro Sample, sodass sich die Tondaten in einem Array aus <tt>unsigned char</tt> ablegen lassen. Die Samples sind dann vorzeichenlos, was bedeutet, dass bei 127 der Mittelwert ist. Als Samplerate reichen für uns auch recht niedrige 8 kHz, das heißt für jede Sekunde Ton werden 8000 Samples benötigt.

== Aufgabenstellung ==
Jetzt soll Schritt für Schritt der Tongenerator implementiert werden.

=== Sinuswellen generieren ===
Schreibe eine Funktion, die Sinuswellen als Mono-8Bit-8kHz-PCM-Daten erzeugt. Der Funktion soll die gewünschte Länge des Tons, die Frequenz des Tons, und die Amplitude, sowie einen Pointer auf ein int, in dem die Anzahl der generierten Samples abgelegt werden kann. Die Funktion soll dann ausreichend Speicher für die Daten allokieren und jedes Sample mit den passenden Sinuswerten befüllen und sie am Ende zurückgeben. Der Prototyp der Funktion sollte also etwa so aussehen:
<pre>unsigned char* generateSine(int ms, int freq, float amplitude, int *numSamples)</pre>

Rufe nun in der main-Funktion die Generierungsfunktion auf und speichere die Daten mit <tt>fwrite</tt> in eine Datei. Die Datei kann jetzt auf einem Linux-System auf einfache Weise abgespielt mit dem Kommando <tt>cat audiofile > /dev/dsp</tt> werden. Sie kann aber auch z.B. mit mplayer abgespielt werden:
<tt>mplayer -rawaudio samplesize=1:channels=1:rate=8000 -demuxer rawaudio audiofile</tt>.

==== Hinweis zum Debuggen ====
Um sich die Audiodaten anzusehen, kann das Programm [http://audacity.sourceforge.net/?lang=de Audacity] verwendet werden. Öffnen lassen sie sich dort über Datei -> Importieren -> Rohdaten, dann die Datei auswählen, dann bei Codec Unsigned 8 bit PCM, bei Kanäle 1, bei Samplefrequenz 8000 Hz auswählen. Nun kann man in die Samples reinzoomen (Button mit Lupe und Plus) und sehen, ob der Sinuswellen ordentlich sind. Mit Analyse -> Frequenzanalyse kann überprüft werden, ob die Sinuswelle die richtige Frequenz hat.

=== Sinuswellen überlagern ===
Schreibe jetzt eine Funktion, die zwei Sinuswellen gleicher Länge überlagern kann. Die von ihr erstellte Samples sollen durch Addition der beiden Samples der Sinusdaten gebildet werden. Doch Vorsicht: da die Daten vorzeichenlos sind, müssen sie temporär vorzeichenbehaftet werden, so dass der Mittelwert 0 (also Wertebereich -128 bis 127) wird, dann können sie addiert werden und dann wieder vorzeichenlos abgespeichert werden (mit dem Mittelwert 127, Wertebereich 0 bis 255). Der Prototyp der Funktion sollte etwa so aussehen:
<pre>unsigned char* mixPcm(unsigned char *a, unsigned char *b, int numSamples)</pre>

Teste nun die Funktion wieder, indem du zwei Sinuswellen unterschiedlicher Frequenz erzeugst und sie mit der neuen Funktion überlagerst. Als Amplitude sollte jeweils etwas weniger als die Hälfte gewählt werden, um bei der Addition [http://de.wikipedia.org/wiki/Clipping_%28Signalverarbeitung%29 Clipping] zu vermeiden. Untersuche das Ergebnis wieder, wie in der ersten Teilaufgabe.

=== DTMF-Töne ===
Schreibe eine Funktion, die für eine Ziffer zwischen 0 und 9 den passenden DTMF-Ton mithilfe der beiden vorigen Funktionen generieren kann. Ihr Prototyp kann etwa so aussehen:
<pre>unsigned char* generateDtmfTone(int number, int ms, int *numSamples)</pre>

Teste wieder. Zum Vergleich der Töne kannst du jetzt ein Telefon benutzen.

=== Nummernsequenzen generieren ===
Benutze jetzt die Generierungsfunktion, um eine Folge von Ziffern in eine Datei zu schreiben. Die Töne sollten durch Stille getrennt sein. Du brauchst also noch eine Funktion, die Samples generiert, die alle den Wert 127 haben. Die Nummer soll als Kommandozeilenparameter oder Benutzereingabe eingegeben werden.

Wenn du jetzt ein analoges Telefon zur Hand hast, kannst du die Töne ins Mikrofon des Hörers anspeilen und damit Nummern wählen.

==== Hinweis ====
Vergesse nicht, alle Tondaten, die du nicht mehr brauchst, mit <tt>free</tt> wieder freizugeben.

== 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 ;)



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

C-Kurs/DTMF-Encoder

2010-09-16T13:28:57Z

Alexander Kührmann: Die Seite wurde neu angelegt: „In dieser Aufgabe soll ein Generator für DTMF-Töne erstellt werden. DTMF steht für Dual-tone multi-frequency und ist auch als [http://de.wikipedia.org/w...“

In dieser Aufgabe soll ein Generator für DTMF-Töne erstellt werden. DTMF steht für Dual-tone multi-frequency und ist auch als [http://de.wikipedia.org/wiki/Mehrfrequenzwahlverfahren Mehrfrequenzwahlverfahren] bekannt.

Wenn du diese Aufgabe in den Rechnerräumen bearbeitest, benutze bei dem Abspielen der Töne bitte Kopfhörer, um andere nicht zu stören.

=== Was ist DTMF? ===
Kurz gesagt: ein DTMF-Ton besteht aus zwei überlagerten Sinuswellen. Für jede Taste auf dem Telefon ist eine bestimmte Frequenzkombination dieser beiden Wellen festgelegt. Genaueres sowie die Frequenzen für die Tasten finden sich [http://de.wikipedia.org/wiki/Mehrfrequenzwahlverfahren hier].

=== Wie werden Töne im Rechner dargestellt? ===
Töne lassen sich als [http://de.wikipedia.org/wiki/Puls-Code-Modulation PCM]-Daten speichnern. Unser Programm soll solche PCM-Daten generieren. Ausreichend sind hier 8 Bit pro Sample, sodass sich die Tondaten in einem Array aus <tt>unsigned char</tt> ablegen lassen. Die Samples sind dann vorzeichenlos, was bedeutet, dass bei 127 der Mittelwert ist. Als Samplerate reichen für uns auch recht niedrige 8 kHz, das heißt für jede Sekunde Ton werden 8000 Samples benötigt.

== Aufgabenstellung ==
Jetzt soll Schritt für Schritt der Tongenerator implementiert werden.

=== Sinuswellen generieren ===
Schreibe eine Funktion, die Sinuswellen als Mono-8Bit-8kHz-PCM-Daten erzeugt. Der Funktion soll die gewünschte Länge des Tons, die Frequenz des Tons, und die Amplitude, sowie einen Pointer auf ein int, in dem die Anzahl der generierten Samples abgelegt werden kann. Die Funktion soll dann ausreichend Speicher für die Daten allokieren und sie mit den passenden Sinuswerten befüllen und sie am Ende zurückgeben. Der Prototyp der Funktion sieht sollte also etwa so aussehen:
<pre>unsigned char* generateSine(int ms, int freq, float amplitude, int *numSamples)</pre>

Rufe nun in der main-Funktion die Generierungsfunktion auf und speichere die Daten mit <tt>fwrite</tt> in eine Datei. Die Datei kann jetzt auf einem Linux-System auf einfache Weise abgespielt mit dem Kommando <tt>cat audiofile > /dev/dsp</tt> werden. Sie kann aber auch z.B. mit mplayer abgespielt werden:
<tt>mplayer -rawaudio samplesize=1:channels=1:rate=8000 -demuxer audiofile</tt>.

==== Hinweis zum Debuggen ====
Um sich die Audiodaten anzusehen, kann das Programm [http://audacity.sourceforge.net/?lang=de Audacity] verwendet werden. Öffnen lassen sie sich dort über Datei -> Importieren -> Rohdaten, dann die Datei auswählen, dann bei Codec Unsigned 8 bit PCM, bei Kanäle 1, bei Samplefrequenz 8000 Hz auswählen. Nun kann man in die Samples reinzoomen (Button mit Lupe und Plus) und sehen, ob der Sinuswellen ordentlich sind. Mit Analyse -> Frequenzanalyse kann überprüft werden, ob die Sinuswelle die richtige Frequenz hat.

=== Sinuswellen überlagern ===
Schreibe jetzt eine Funktion, die zwei Sinuswellen gleicher Länge überlagern kann. Die von ihr erstellte Samples sollen durch Addition der beiden Samples der Sinusdaten gebildet werden. Doch Vorsicht: da die Daten vorzeichenlos sind, müssen sie temporär vorzeichenbehaftet werden, so dass der Mittelwert 0 wird, dann können sie addiert werden und dann wieder vorzeichenlos abgespeichert werden (mit dem Mittelwert 127). Der Prototyp der Funktion sollte etwa so aussehen:
<pre>unsigned char* mixPcm(unsigned char *a, unsigned char *b, int numSamples)</pre>

Test nun die Funktion wieder, indem du zwei Sinuswellen unterschiedlicher Frequenz erzeugst und sie mit der neuen Funktion überlagerst. Als Amplitude sollte jeweils etwas weniger als die Hälfte gewählt werden, um bei der Addition [http://de.wikipedia.org/wiki/Clipping_%28Signalverarbeitung%29 Clipping] zu vermeiden. Untersuche das Ergebnis wieder, wie in der ersten Teilaufgabe.

=== DTMF-Töne ===
Schreibe eine Funktion, die für eine Ziffer zwischen 0 und 9 den passenden DTMF-Ton mithilfe der beiden vorigen Funktionen generieren kann. Ihr Prototyp kann etwa so aussehen:
<pre>unsigned char* generateDtmfTone(int number, int ms, int *numSamples)</pre>

Teste wieder. Zum Vergleich der Töne kannst du jetzt ein Telefon benutzen.

=== Nummernsequenzen generieren ===
Benutze jetzt die Generierungsfunktion, um eine Folge von Ziffern in eine Datei zu schreiben. Die Töne sollten durch Stille getrennt sein. Du brauchst also noch eine Funktion, die Samples generiert, die alle den Wert 127 haben. Die Nummer soll als Kommandozeilenparameter oder Benutzereingabe eingegeben werden.

Wenn du jetzt ein analoges Telefon zur Hand hast, kannst du die Töne ins Mikrofon des Hörers anspeilen und damit Nummern wählen.

== 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 ;)



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

C-Kurs 2010/Vortrag01

2010-09-15T16:47:28Z

Alexander Kührmann: /* Einführung */

= Einführung =

Vortragende: '''Paul''' <email>p.brodmann@gmx.de</email>

=== Themen ===
* Organisatorisches
* Konzept von C
** Syntax
** Operatoren
* Hello World
* Compilereinführung

=== Folien ===
* [http://docs.freitagsrunde.org/Veranstaltungen/ckurs_2010/vortraege/01/Ckurs2010%20Vortrag1.pdf Folien]

=== Mitschnitt ===

==== Mittschnitt 2010 ====
[http://freitagsrunde.org/~jungnickel/PaulMaster.mov HighQuality] 1,1 GB

Flash Version folgt

==== Mittschnitt 2010 ====
<dhflashplayer>filepath=http://stan.freitagsrunde.org/c0/LE01.mp4|width=720|height=576</dhflashplayer>

==== Mittschnitt 2009 ====
* Audio: http://podcasts.freitagsrunde.org/C-Kurs-2009/ckurs_vl01.mp3
* [http://stan.freitagsrunde.org/c9/LE01.mp4 High Quality] (204MB x264|ada2ce460c64fa15867ebf7b53a0db2c)
* [http://stan.freitagsrunde.org/c9/1-VL.mp3 Audio Podcast] (22MB mp3)

 

[[Kategorie:CKurs]]

C-Kurs/Übungsaufgaben

2010-09-15T13:39:25Z

Alexander Kührmann: /* Die Aufgaben */

Wir haben jeder Aufgabe eine Einschätzung ihrer Schwierigkeit auf einer Skala von 1 bis 10 vorangestellt. Bei dieser Einschätzung sind wir von einem Gehirn ausgegangen, für welches das jeweilige Themengebiet völlig neu ist, das jedoch schon ein ganz gutes Verständnis dafür hat wie eine Programmiersprache denn so funktioniert.
Entsprechend kann eine schwer bewertete Aufgabe aus einem frühen Themengebiet für manch einen sehr einfach oder eine leicht bewertete aus einem späten Themengebiet für einen anderen sehr schwer sein. Es ist nur ein Wert, der euch helfen soll eure nächste Aufgabe zu wählen.

Falls ihr Anmerkungen zu den Aufgaben habt, könnt ihr die Diskussionsseiten der jeweiligen Aufgaben nutzen.

== Schwierigkeitsgrade ==

# Reines Tutorial. Man muss nicht viel selbst denken
# ...
# Leichte Übungsaufgabe. Studies, die noch eher unsicher sind werden hier gut begleitet.
# ...
# Typische Aufgabe. Man muss den Kopf benutzen, bekommt an schwierigen Stellen aber Hilfestellungen.
# ...
# Herausfordernd, eher etwas für Studies die etwas fitter sind.
# ...
# Auch erfahrene Programmierer werden hier ein bis zwei Übungen beschäftigt sein 
# Tja, die Idee war da. Wir finden sie auch gut, aber es könnte wirklich anstrengend werden.

== Die Aufgaben ==

{| class="wikitable sortable" border="0" cellpadding="4" cellspacing="2"}

|- bgcolor="#D8D8D8"
!Aufgabe
!Schwierigkeit
!Vorwissen
!Lerneffekte
!Bearbeiter
!Korrektur gelesen
!Musterlösung
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Von der Konsole zum HelloWorld | Von der Konsole zum HelloWorld]]
| align="center" |1
| align="center" |1. VL
| Konsole benutzen, Hello World
| Sebastian D.
| [[Benutzer:Mario|Mario]] (2009),
|
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Fakultät | Fakultät]]
| align="center" |2
| align="center" |1. VL
| Schleifen
| Sebastian D.
| Daniel (2009),
|
|- bgcolor="#F5F5F5"
| [[Ckurs2010/Pythagoras-Triplet | Pythagoras-Triplet]]
| align="center" |2
| align="center" |1. VL
| Schleifen if-Bedingungen
| Gabriel P.
| seba(2010)
| 
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Fibonacci-Folge|Fibonacci-Folge]]
| align="center" |2
| align="center" |1. VL
| Funktionen Rekursion
| Paul B.
| [[Benutzer:Mario|Mario]] (2010)
| 
|- bgcolor="#F5F5F5"
| [[Ckurs2009/digitalesSchloesserKnacken|digitales Schloesser knacken]]
| align="center" |4
| align="center" |1. VL
| Kontrollstrukturen Bitweise Operatoren
| Paul B.
| Eugen R. (2010)
| 
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Rekursives_arbeiten|Rekursives Arbeiten]]
| align="center" |3-5
| align="center" |1. VL
| Bekannte Operatoren wie + durch Funktionen succ und neg nachbilden
| Eugen R.
| Paul B.(2010)
| 
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Base64 | Base64]]
| align="center" |6
| align="center" |1. VL
| Operatoren
| Sebastian D.
| Paul B.(2010)
| 
|- bgcolor="#E8E8E8"
| [[Ckurs2009/EingabeAusgabe | Ein- und Ausgabe]]
| align="center" |1
| align="center" |2. VL
| Einlesen von Benutzereingaben Ausgabe derselben
| [[Benutzer:Mario|Mario]]
| nion (2009),
| 
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Taschenrechner | Taschenrechner]]
| align="center" |3
| align="center" |2. VL
| Eingabe+Ausgabe Mathematische Operatoren
| [[Benutzer:Mario|Mario]]
| [[Benutzer:Tkroenert|TKroenert]] (2009),
| 
|- bgcolor="#E8E8E8"
| [[Ckurs2009/VerschachtelteSchleifen | Verschachtelte Schleifen]]
| align="center" |3
| align="center" |2. VL
| Umgang mit mehreren verschachtelten Schleifen
| [[Benutzer:Dank|Daniel K.]]
| AlexanderK (2009),
|
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Glückspiel | Glücksspiel]]
| align="center" |3
| align="center" |2. VL
| Anwenden von Fallunterscheidungen und Einlesen von Werten aus der Konsole
| [[Benutzer:Dank|Daniel K.]]
| AlexanderK (2009),
| 
|- bgcolor="#E8E8E8"
| [[Ckurs/Buchstaben_zählen | Buchstaben zählen]]
| align="center" |4
| align="center" |2. VL
| Array, Dateien lesen
| Alex K.
| Gabriel (2010)
| 
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Wochentag | Wochentagsrechnung]]
| align="center" |5
| align="center" |2. VL
| Einlesen von Benutzereingaben Mathematikverständniss
| [[Benutzer:Mario|Mario]]
| nion (Musterlösung noch nicht vorhanden) (2009),
|
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Taschenrechner2.0 | Taschenrechner ''2.0'']]
| align="center" |8
| align="center" |2. VL
| Knobeln Komplexes Aufgaben lösen
| [[Benutzer:Mario|Mario]]
| Martin K. (2009),
| 
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Call by reference | Call by reference]]
| align="center" |4
| align="center" |3. VL
| Einfache Anwendung von &/*
| sping
| nion (2009), Alex K. (2010)
| 
|- bgcolor="#F5F5F5"
| [[Ckurs2010/String to Double | String to Double]]
| align="center" |5
| align="center" |3. VL
| Original-Dokumentation anwenden (Opengroup, man pages) Pointer auf Pointer Const correctness Strings
| sping
| Eugen R. (2010)
| 
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Text processing | Text processing]]
| align="center" |4, 6
| align="center" |3. VL
| Strings Pointer-Arithmetik Pointer auf Pointer Refactoring
| sping
| [[Benutzer:Mario|Mario]] (2009),
| 
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Palindrome | Palindrome]]
| align="center" |4
| align="center" |3. VL
| Pointer und Strings
| [[Benutzer:Dank|Daniel K.]]
| nion (2009),
| 
|- bgcolor="#F5F5F5"
| [[Ckurs2009/(Pointer) Swapping | (Pointer) Swapping]]
| align="center" |5
| align="center" |3. VL
| Pointer und Arrays benutzen, generisches swap
| Katrin
| Katrin (2010, wird nochmal überarbeitet bzw. mit mehr erklärendem Text versehen)
| 
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Matrizenmultiplikation | Matrizenmultiplikation]]
| align="center" |6
| align="center" |3. VL
| Mehrdimensionale Arrays const correctness
| sping
| [[Benutzer:Mario|Mario]] (2009),
| 
|- bgcolor="#F5F5F5"
| [[Ckurs/DreiD | 3D mit C]]
| align="center" |6-9
| align="center" |3. VL
| Mathematische Rechenoperationen, Algorithmik
| AndreasF
|
| 
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Arrayuebergabe | Arrayuebergabe]]
| align="center" |4/5
| align="center" |4. VL
| Einlesen von Benutzereingaben Pointer und Pointerarithmetik
| nion
| Martin K. (2009),
| 
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Studentendatenbank | Studentendatenbank]]
| align="center" |4
| align="center" |4. VL
| struct, Pointer, Arrays
| AlexanderK
| Gabriel (2010)
| 
|- bgcolor="#E8E8E8"
| [[Ckurs2010/Punktstrukturen| Punktstrukturen]]
| align="center" |2-3
| align="center" |4. VL
| Structs, Unions, Pointer
| [[Benutzer:Mutax|Florian]] (2010)
| Alex K. (2010)
|
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Sammelbestellung | Sammelbestellung]]
| align="center" |2-5
| align="center" |4. VL
| Listen, Pointer, Speicherverwaltung
| [[Benutzer:Mutax|Florian]]
| [[Benutzer:Mario|Mario]] (2009),
| 
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Zahlen_sagen | Zahlen sagen]]
| align="center" |5
| align="center" |4. VL
| Umgang mit Zeichenketten
| Martin K.
| Paul B. (w.i.p.)
| 
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Compiler, Präprozessor, Header Files | Compiler, Präprozessor, Header Files]]
| align="center" |3
| align="center" |5. VL
| Arbeiten mit mehreren Quellcode-Dateien, Kompilieren und Linken, Header-Dateien und #include, debugging-Makro verwenden
| Katrin
| AndyF (2010)
| 
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Bus Error | Bus Error]]
| align="center" |8
| align="center" |5. VL
| Pointer, wie entsteht ein bus error
| Katrin
| [[Benutzer:Mario|Mario]] (2010)
| 
|- bgcolor="#F5F5F5"
| [[Ckurs2009/BubbleSortDebug | BubbleSort Debugging]]
| align="center" |5
| align="center" |6. VL
| Debuggen eines Programmes mit gdb
| aeichner
|
| 
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Debug | Debugging]]
| align="center" |1-8
| align="center" |6. VL
| Debuggen einer Anwendung nach Wahl
| aeichner
|
|
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Code Layout | Code Layout]]
| align="center" |3
| align="center" |7. VL
| Kleinere Codeschipsel mit kleinen Unsauberkeiten
| Daniel
| [[Benutzer:Tkroenert|TKroenert]] (2010)
| 
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Refactoring | Refactoring]]
| align="center" |5-9
| align="center" |7. VL
| Wie verbessere ich den Quellcode eines Programmes.
| Daniel
|
| 
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Cat | Cat]]
| align="center" |6
| align="center" |2. VL
| Arbeiten mit Dateien Kommandozeilenparameter
| nion
| sping (2009),
| 
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Pong | Pong]]
| align="center" |7
| align="center" |9.VL (eigentlich 2.VL)
| allgemeiner Programmablauf, fortgeschrittene Konsolenausgaben/eingaben
| AlexanderK
| seba(2010)
| 
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Buchhaltung | Buchhaltung]]
| align="center" |6
| align="center" |5.VL
| Lesen aus Dateien
| reiner
| AndyF (2010)
|
|- bgcolor="#E8E8E8"
| [[Ckurs2009/StringArraySortieren | StringArraySortieren]]
| align="center" |8
| align="center" |3. VL
| Konsolparameter, Funktionspointer, stdlib
| reiner
| martin (2010)
| 
|- bgcolor="#F5F5F5"
| [[Ckurs/integral | integral]]
| align="center" |2
| align="center" |3. VL
| Funktionspointer
| reiner
| [[Benutzer:Tkroenert|TKroenert]] (2010)
| 
|- bgcolor="#E8E8E8"
| [[Ckurs/forschleife | forschleife]]
| align="center" |3
| align="center" |6. VL
| Bug (zum Knobeln)
| reiner
| nion (2009), [[Benutzer:Tkroenert|TKroenert]] (2010)
| 
|- bgcolor="#F5F5F5"
| [[Ckurs/libgdsl | GDSL]]
| align="center" |5-7
| align="center" |9. VL
| Anwendung der Generic Data Structures Library
| martin
|
|
|- bgcolor="#E8E8E8"
| [[Ckurs2009/StdLib | Standard C Library]]
| align="center" |3
| align="center" |9. VL
| Recherche in der Standard C Bibliothek
| martin
|
|
|- bgcolor="#F5F5F5"
| [[Ckurs/Tron | Tron]]
| align="center" |7-9
| align="center" |4. VL
| SDL (Simple Directmedia Layer) kennen lernen, graphische Ausgabe
| seba
|
| 
|- bgcolor="#E8E8E8"
| [[Ckurs2010/TicTacToe | TicTacToe]]
| align="center" |5-7
| align="center" |9. VL
| SDL (Simple Directmedia Layer) kennen lernen, graphische Ausgabe
| Martin
|
| 
|}

== Kleine und große Probleme ==

* Die Tubit-Accounts haben nicht /bin/bash als shell, so dass die Cursortasten nicht funktionieren. Workaround: als erstes Kommando 'bash' eingeben, man sieht dann auch in welchem Verzeichnis man gerade ist.
* wenn man nur den Promt 'bash-0.12' oder so erhält, also ohne das Verzeichnis in dem man ist, folgendes Kommando eingeben: <tt>export PS1='\u@\h:\w$ '</tt> oder zum dauerhaften Speichern: <tt> echo "export PS1='\u@\h:\w$ '" >> ~/.bashrc </tt>

== Musterlösungen ==
Die Lösungen zu den Aufgaben werden nach den jeweiligen Übungen hier veröffentlicht. Falls dies nicht geschieht, bitte den zuständigen Tutor fragen.

== Links ==

* [[Ckurs2009/Feedback|Feedback zum Kurs 2009]]

[[Kategorie:CKurs]]
[[Kategorie:CKurs Aufgaben]]

C-Kurs/Punktstrukturen

2010-09-14T17:17:46Z

Alexander Kührmann:

In dieser Aufgabe soll eine Programm erstellt werden, dass Punkte in verschiedenen Koordinatensystemen 'verwalten' und beim Rechnen automatisch konvertieren kann.

== Aufgaben ==

=== Teil a ===

Schreibe je eine struct <tt>punkt_cart</tt> und <tt>punkt_polar</tt>, die einen Punkt in Kartesischen bzw. Polarkoordinaten beschreibt sowie Hilfsfunktionen, um solche Punkte zu erzeugen und die Entfernung zwischen Punkten desselben Koordinatensystems zu berechnen.

=== Teil b ===

Schreibe Hilfsfunktionen, die die Punkte von einem Typ in einen anderen konvertieren. Dabei soll die bei C typische Vorgehensweise beachtet werden:

Zunächst wird für den neuen Punkt Speicher alloziiert, dann wird die Hilfsfunktion mit zwei Pointern aufgerufen - dem vorhandenen Punkt und dem Speicherplatz für den umgewandelten Punkt. Der Rückgabewert der Hilfsfunktion soll angeben, ob die Konvertierung erfolgreich war.

=== Teil c ===

Schreibe das Programm nun so um, dass es nur noch eine Art von Punkten gibt. Diese soll intern eine union enthalten, um beide Arten von Koordinatensystemen verarbeiten zu können. In der umgebenden struct soll in einem enum der Typ des Koordinatensystems gespeichert werden.

Die Hilfsfunkion zum Berechnen der Entfernungen zwischen Punkten soll nun mit unterschiedlichen Punkten aufgerufen werden können und die korrekte Entfernung der Punkte zueinander ausgeben.

=== Zusatzaufgabe ===
Schreibe ein Programm, dass die Koordinaten und Farben von Punkten auf der Standardeingabe entgegennimmt. Anhand der Eingabe soll das Koordinatensystem erkannt werden (float, int) rrggbb oder (int,int) rrggbb.

Das Programm soll dann die Entfernung aller Punkte zueinander berechnen und die Punkte grafisch darstellen.

== 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 ;)

C-Kurs/Übungsaufgaben

2010-09-14T17:08:17Z

Alexander Kührmann: /* Die Aufgaben */ zwei Reviews für mich

Wir haben jeder Aufgabe eine Einschätzung ihrer Schwierigkeit auf einer Skala von 1 bis 10 vorangestellt. Bei dieser Einschätzung sind wir von einem Gehirn ausgegangen, für welches das jeweilige Themengebiet völlig neu ist, das jedoch schon ein ganz gutes Verständnis dafür hat wie eine Programmiersprache denn so funktioniert.
Entsprechend kann eine schwer bewertete Aufgabe aus einem frühen Themengebiet für manch einen sehr einfach oder eine leicht bewertete aus einem späten Themengebiet für einen anderen sehr schwer sein. Es ist nur ein Wert, der euch helfen soll eure nächste Aufgabe zu wählen.

Falls ihr Anmerkungen zu den Aufgaben habt, könnt ihr die Diskussionsseiten der jeweiligen Aufgaben nutzen.

== Schwierigkeitsgrade ==

# Reines Tutorial. Man muss nicht viel selbst denken
# ...
# Leichte Übungsaufgabe. Studies, die noch eher unsicher sind werden hier gut begleitet.
# ...
# Typische Aufgabe. Man muss den Kopf benutzen, bekommt an schwierigen Stellen aber Hilfestellungen.
# ...
# Herausfordernd, eher etwas für Studies die etwas fitter sind.
# ...
# Auch erfahrene Programmierer werden hier ein bis zwei Übungen beschäftigt sein 
# Tja, die Idee war da. Wir finden sie auch gut, aber es könnte wirklich anstrengend werden.

== Die Aufgaben ==

{| class="wikitable sortable" border="0" cellpadding="4" cellspacing="2"}

|- bgcolor="#D8D8D8"
!Aufgabe
!Schwierigkeit
!Vorwissen
!Lerneffekte
!Bearbeiter
!Korrektur gelesen
!Musterlösung
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Von der Konsole zum HelloWorld | Von der Konsole zum HelloWorld]]
| align="center" |1
| align="center" |1. VL
| Konsole benutzen, Hello World
| Sebastian D.
| [[Benutzer:Mario|Mario]] (2009),
|
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Fakultät | Fakultät]]
| align="center" |2
| align="center" |1. VL
| Schleifen
| Sebastian D.
| Daniel (2009),
|
|- bgcolor="#F5F5F5"
| [[Ckurs2010/Pythagoras-Triplet | Pythagoras-Triplet]]
| align="center" |2
| align="center" |1. VL
| Schleifen if-Bedingungen
| Gabriel P.
| seba(in arbeit)
| [[Ckurs2010/Pythagoras-Triplet/Musterloesung | Pythagoras-Triplet]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Fibonacci-Folge|Fibonacci-Folge]]
| align="center" |2
| align="center" |1. VL
| Funktionen Rekursion
| Paul B.
| [[Benutzer:Mario|Mario]] (2010)
| [[Ckurs2009/Fibonacci-Folge/Musterlösung | Fibonacci-Folge]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/digitalesSchloesserKnacken|digitales Schloesser knacken]]
| align="center" |4
| align="center" |1. VL
| Kontrollstrukturen Bitweise Operatoren
| Paul B.
| Eugen R. (2010)
| [[Ckurs2009/digitalesSchloesserKnacken/Musterlösung | digitales Schloesser knacken]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Rekursives_arbeiten|Rekursives Arbeiten]]
| align="center" |3-5
| align="center" |1. VL
| Bekannte Operatoren wie + durch Funktionen succ und neg nachbilden
| Eugen R.
| Paul B.(2010)
| [[Ckurs2009/Rekursives_arbeiten/Musterlösung | Rekursives Arbeiten]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Base64 | Base64]]
| align="center" |6
| align="center" |1. VL
| Operatoren
| Sebastian D.
| Paul B.(2010)
| [[Ckurs2009/Base64/Musterlösung | Base64]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/EingabeAusgabe | Ein- und Ausgabe]]
| align="center" |1
| align="center" |2. VL
| Einlesen von Benutzereingaben Ausgabe derselben
| [[Benutzer:Mario|Mario]]
| nion (2009),
| [[Ckurs2009/EingabeAusgabe/Musterlösung | Ein- und Ausgabe]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Taschenrechner | Taschenrechner]]
| align="center" |3
| align="center" |2. VL
| Eingabe+Ausgabe Mathematische Operatoren
| [[Benutzer:Mario|Mario]]
| [[Benutzer:Tkroenert|TKroenert]] (2009),
| [[Ckurs2009/Taschenrechner/Musterlösung | Taschenrechner]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/VerschachtelteSchleifen | Verschachtelte Schleifen]]
| align="center" |3
| align="center" |2. VL
| Umgang mit mehreren verschachtelten Schleifen
| [[Benutzer:Dank|Daniel K.]]
| AlexanderK (2009),
|
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Glückspiel | Glücksspiel]]
| align="center" |3
| align="center" |2. VL
| Anwenden von Fallunterscheidungen und Einlesen von Werten aus der Konsole
| [[Benutzer:Dank|Daniel K.]]
| AlexanderK (2009),
| [[Ckurs2009/Glückspiel/Musterlösung | Glückspiel]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Wochentag | Wochentagsrechnung]]
| align="center" |5
| align="center" |2. VL
| Einlesen von Benutzereingaben Mathematikverständniss
| [[Benutzer:Mario|Mario]]
| nion (Musterlösung noch nicht vorhanden) (2009),
|
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Taschenrechner2.0 | Taschenrechner ''2.0'']]
| align="center" |8
| align="center" |2. VL
| Knobeln Komplexes Aufgaben lösen
| [[Benutzer:Mario|Mario]]
| Martin K. (2009),
| [[Ckurs2009/Taschenrechner2.0/Musterlösung | Taschenrechner ''2.0'']]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Call by reference | Call by reference]]
| align="center" |4
| align="center" |3. VL
| Einfache Anwendung von &/*
| sping
| nion (2009), Alex K. (2010)
| [[Ckurs2009/Call by reference/Musterlösung | Call by reference]]
|- bgcolor="#F5F5F5"
| [[Ckurs2010/String to Double | String to Double]]
| align="center" |5
| align="center" |3. VL
| Original-Dokumentation anwenden (Opengroup, man pages) Pointer auf Pointer Const correctness Strings
| sping
| Eugen R. (2010)
| vorhanden
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Text processing | Text processing]]
| align="center" |4, 6
| align="center" |3. VL
| Strings Pointer-Arithmetik Pointer auf Pointer Refactoring
| sping
| [[Benutzer:Mario|Mario]] (2009),
| [[Ckurs2009/Text processing/Musterlösung | Text processing]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Palindrome | Palindrome]]
| align="center" |4
| align="center" |3. VL
| Pointer und Strings
| [[Benutzer:Dank|Daniel K.]]
| nion (2009),
| [[Ckurs2009/Palindrome/Musterlösung | Palindrome ]]
|- bgcolor="#E8E8E8"
| [[Ckurs/Buchstaben_zählen | Buchstaben zählen]]
| align="center" |4
| align="center" |3. VL
| Array, Dateien lesen
| Alex K.
| Gabriel (2010)
| vorhanden
|- bgcolor="#F5F5F5"
| [[Ckurs2009/(Pointer) Swapping | (Pointer) Swapping]]
| align="center" |5
| align="center" |3. VL
| Pointer und Arrays benutzen, generisches swap
| Katrin
| Katrin (2010, wird nochmal überarbeitet bzw. mit mehr erklärendem Text versehen)
| [[Ckurs2009/(Pointer) Swapping/Musterlösung | (Pointer) Swapping]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Matrizenmultiplikation | Matrizenmultiplikation]]
| align="center" |6
| align="center" |3. VL
| Mehrdimensionale Arrays const correctness
| sping
| [[Benutzer:Mario|Mario]] (2009),
| [[Ckurs2009/Matrizenmultiplikation/Musterlösung | Matrizenmultiplikation]]
|- bgcolor="#F5F5F5"
| [[Ckurs/DreiD | 3D mit C]]
| align="center" |6-9
| align="center" |3. VL
| Mathematische Rechenoperationen, Algorithmik
| AndreasF
|
| vorhanden
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Arrayuebergabe | Arrayuebergabe]]
| align="center" |4/5
| align="center" |4. VL
| Einlesen von Benutzereingaben Pointer und Pointerarithmetik
| nion
| Martin K. (2009),
| [[Ckurs2009/Arrayuebergabe/Musterlösung | Arrayuebergabe]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Studentendatenbank | Studentendatenbank]]
| align="center" |4
| align="center" |4. VL
| struct, Pointer, Arrays
| AlexanderK
| Gabriel (2010)
| [[Ckurs2009/Studentendatenbank/Musterlösung | Studentendatenbank]]
|- bgcolor="#E8E8E8"
| [[Ckurs2010/Punktstrukturen| Punktstrukturen]]
| align="center" |2-3
| align="center" |4. VL
| Structs, Unions, Pointer
| [[Benutzer:Mutax|Florian]] (2010)
| Alex K. (2010)
| -
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Sammelbestellung | Sammelbestellung]]
| align="center" |2-5
| align="center" |4. VL
| Listen, Pointer, Speicherverwaltung
| [[Benutzer:Mutax|Florian]]
| [[Benutzer:Mario|Mario]] (2009),
| [[Ckurs2009/Sammelbestellung/Musterlösung | Sammelbestellung]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Zahlen_sagen | Zahlen sagen]]
| align="center" |5
| align="center" |4. VL
| Umgang mit Zeichenketten
| Martin K.
| Paul B. (w.i.p.)
| [[Ckurs2009/Zahlen_sagen/Musterlösung | Zahlen sagen]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Compiler, Präprozessor, Header Files | Compiler, Präprozessor, Header Files]]
| align="center" |3
| align="center" |5. VL
| Arbeiten mit mehreren Quellcode-Dateien, Kompilieren und Linken, Header-Dateien und #include, debugging-Makro verwenden
| Katrin
| AndyF (2010)
| [https://wiki.freitagsrunde.org/Ckurs2009/Vortrag05 siehe Folien]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Bus Error | Bus Error]]
| align="center" |8
| align="center" |5. VL
| Pointer, wie entsteht ein bus error
| Katrin
| [[Benutzer:Mario|Mario]] (2010)
| [[Ckurs2009/Bus Error/Musterlösung | Bus Error]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/BubbleSortDebug | BubbleSort Debugging]]
| align="center" |5
| align="center" |6. VL
| Debuggen eines Programmes mit gdb
| aeichner
|
| [[Ckurs2009/BubbleSortDebug/Musterlösung | BubbleSort Debugging]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Debug | Debugging]]
| align="center" |1-8
| align="center" |6. VL
| Debuggen einer Anwendung nach Wahl
| aeichner
|
|
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Code Layout | Code Layout]]
| align="center" |3
| align="center" |7. VL
| Kleinere Codeschipsel mit kleinen Unsauberkeiten
| Daniel
| [[Benutzer:Tkroenert|TKroenert]] (2010)
| [[Ckurs2009/Code Layout/Musterlösung | Code Layout]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Refactoring | Refactoring]]
| align="center" |5-9
| align="center" |7. VL
| Wie verbessere ich den Quellcode eines Programmes.
| Daniel
|
| [[Ckurs2009/Refactoring/Musterlösung | Refactoring]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Cat | Cat]]
| align="center" |6
| align="center" |2. VL
| Arbeiten mit Dateien Kommandozeilenparameter
| nion
| sping (2009),
| vorhanden
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Pong | Pong]]
| align="center" |7
| align="center" |9.VL (eigentlich 2.VL)
| allgemeiner Programmablauf, fortgeschrittene Konsolenausgaben/eingaben
| AlexanderK
| seba(2010)
| vorhanden
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Buchhaltung | Buchhaltung]]
| align="center" |6
| align="center" |5.VL
| Lesen aus Dateien
| reiner
| AndyF (2010)
|
|- bgcolor="#E8E8E8"
| [[Ckurs2009/StringArraySortieren | StringArraySortieren]]
| align="center" |8
| align="center" |3. VL
| Konsolparameter, Funktionspointer, stdlib
| reiner
|
| vorhanden
|- bgcolor="#F5F5F5"
| [[Ckurs/integral | integral]]
| align="center" |2
| align="center" |3. VL
| Funktionspointer
| reiner
| [[Benutzer:Tkroenert|TKroenert]] (2010)
| [[Ckurs/integral/Musterlösung | Musterloesung]]
|- bgcolor="#E8E8E8"
| [[Ckurs/forschleife | forschleife]]
| align="center" |3
| align="center" |6. VL
| Bug (zum Knobeln)
| reiner
| nion (2009), [[Benutzer:Tkroenert|TKroenert]] (2010)
| vorhanden
|- bgcolor="#F5F5F5"
| [[Ckurs/libgdsl | GDSL]]
| align="center" |5-7
| align="center" |9. VL
| Anwendung der Generic Data Structures Library
| martin
|
|
|- bgcolor="#E8E8E8"
| [[Ckurs2009/StdLib | Standard C Library]]
| align="center" |3
| align="center" |9. VL
| Recherche in der Standard C Bibliothek
| martin
|
|
|- bgcolor="#F5F5F5"
| [[Ckurs/Tron | Tron]]
| align="center" |7-8
| align="center" |4. VL
| SDL (Simple Directmedia Layer) kennen lernen, graphische Ausgabe
| seba
|
| vorhanden
|}

== Kleine und große Probleme ==

* Die Tubit-Accounts haben nicht /bin/bash als shell, so dass die Cursortasten nicht funktionieren. Workaround: als erstes Kommando 'bash' eingeben, man sieht dann auch in welchem Verzeichnis man gerade ist.
* wenn man nur den Promt 'bash-0.12' oder so erhält, also ohne das Verzeichnis in dem man ist, folgendes Kommando eingeben: <tt>export PS1='\u@\h:\w$ '</tt> oder zum dauerhaften Speichern: <tt> echo "export PS1='\u@\h:\w$ '" >> ~/.bashrc </tt>

== Musterlösungen ==
Die Lösungen zu den Aufgaben werden nach den jeweiligen Übungen hier veröffentlicht. Falls dies nicht geschieht, bitte den zuständigen Tutor fragen.

== Links ==

* [[Ckurs2009/Feedback|Feedback zum Kurs 2009]]

[[Kategorie:CKurs]]
[[Kategorie:CKurs Aufgaben]]

C-Kurs/Buchstaben zählen/Musterlösung

2010-09-13T11:30:07Z

Alexander Kührmann: Die Seite wurde neu angelegt: „<pre> #include <stdio.h> #include <stdlib.h> void printBar(int length) { int i; for (i = 0; i < length; i++) { printf("#"); } } int main(int...“

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

void printBar(int length) {
int i;
for (i = 0; i < length; i++) {
printf("#");
}
}

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;
}

// initialize counting array
int counts[26] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int allCount = 0;

// read every character in the file and count if it's a letter
while (1) {
int character = fgetc(file);
if (character < 0) {
// we reached end of file
break;
}
if (character >= 'A' && character <= 'Z') {
// we found a capital letter
counts[character - 'A']++;
allCount++;
} else if (character >= 'a' && character <= 'z') {
// we found a letter
counts[character - 'a']++;
allCount++;
}
}

// close the file
fclose(file);

// print the results
int i;
for (i = 0; i < 26; i++) {
printf("%c : %3d ", (char)(i + 'A'), counts[i]);
printBar((counts[i] * 300) / allCount);
printf("\n");
}
}
</pre>

C-Kurs/Buchstaben zählen

2010-09-13T11:27:53Z

Alexander Kührmann: Aufgabenstellung präzisiert und Zusatzaufgabe

== 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 ;)



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

Freitagsrunde:Mitglieder

2009-12-10T18:14:44Z

Alexander Kührmann:

''Mitglieder'' ist vielleicht nicht das richtige Wort, denn es gibt bei uns keine feste Mitgliedschaft, jeder der mitmachen möchte, ist herzlich willkommen und niemand ist zu irgendetwas gezwungen. Auf dieser Seite möchten wir, die Leute die hinter der [[Freitagsrunde]] stehen, uns Euch kurz vorstellen.

(zu den [[Freitagsrunde:Ehemalige_Mitglieder|ehemaligen Mitgliedern]].)

== Dirk Babendererde (<email>dirk@freitagsrunde.org</email>) ==
[[Bild:DirkBabendererde.jpg|thumb|150px|Dirk Babendererde]]
Hallo, ich bin der Dirk und möchte diesen sinnlosen Text demnächst gegen einen sinnvollen Text ersetzen.

 

== Mario Bodemann ([mailto:mario@freitagsrunde.org mario@freitagsrunde.org]) ==
[[Bild:Mario.jpg|thumb|150px|Mario Bodemann]]
Seitdem ich im Sommer 2004 mein Abi abgeschlossen habe, studiere ich hier an der TU B Informatik auf Diplom.

Ich engagiere mich für Belange, die es rund um das Studium gibt. So bin ich
aktiv in der Ausbildungskommision, der Einführungswoche, dem Eclipsekurs 2008 und dem was sonst noch so anfällt. Als Studienschwerpunkte habe ich Computer Graphics und Software Technik, von denen ich erwarte, dass Sie eine gute Kombination ergeben könnten ...

Und falls jemand T-Shirts oder
sonstige Fanartikel von der Freitagsrunde haben will, dann bin ich euer Ansprechpartner :-)
 

== Robert Buchholz ([mailto:rbu@freitagsrunde.org rbu@freitagsrunde.org]) ==
[[Bild:Foto-Robert-Buchholz.jpg|thumb|150px|Robert Buchholz]]
Ich studiere an der TU Berlin seit dem Sommer 2004 und werde bald mit dem Informatik-Diplom abschließen. In der Freitagsrunde bin ich erst seit 2006 mit dabei, konnte mich aber seitdem an vielen Projekten beteiligen. Neben den Java- und Eclipsekursen habe ich großen Spaß an [[Linux-Installationsparty]]s und Ähnlichem. Ich habe im letzten Jahr [[Opalix 2006]] erstellt, und hoffe bald mal mit der [[AG Rechnerinstallation]] aus dem Knick zu kommen.

Was ich innerhalb und außerhalb der Freitagsrunde sonst so organisiere, erfahrt ihr über [[Benutzer:Buchholz|meine Benutzerseite]].
 

== Kai Dietrich ([mailto:kai@freitagsrunde.org kai@freitagsrunde.org]) ==
[[Bild:Foto-Kai-Dietrich.jpg|thumb|150px|Kai Dietrich]]
Ich studiere seit dem WS2003/04 Informatik an der TU Berlin. Obwohl ich der Freitagsrunde (natuerlich) schon in der Einfuehrungswoche begegnet bin, habe ich erst im WS2006/07 hier her gefunden und festgestellt, dass studieren viel mehr Spass macht, wenn man es gemeinsam tut.
Im uebrigen bin ich, als Verfechter des amerikanischen Tastaturlayouts, gegen Umlaute.
[[Benutzer:Cleeus|...read more]]
 

== Michael Dietzel ([mailto:michael.dietzel(_A.T_)mailbox.tu-berlin.de michael.dietzel-_A.T_)mailbox.tu-berlin.de]) ==
[[Bild:Foto-Michael-Dietzel.jpg|thumb|150px|Michael Dietzel]]
Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Ut consectetuer, tortor ac pretium laoreet, enim lectus iaculis ante, sit amet aliquet nisl diam tempus magna. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Aliquam orci. Quisque egestas. Donec ullamcorper, pede ac ultricies venenatis, leo nisi rutrum sem, id congue nibh nisl vel nulla. Praesent id mi. Vivamus enim neque, elementum vel, elementum sed, pretium et, arcu. Curabitur leo. Etiam tristique orci viverra ligula. Nam ultricies. Donec aliquet varius elit. Maecenas massa. Nullam justo. Donec sagittis magna id lectus ultrices semper. Etiam laoreet lorem quis purus. Nam justo purus, euismod ut, porta a, eleifend id, pede. Sed tincidunt ipsum a arcu.
[[Benutzer:mimos|...read more]]
 

== Sebastian Drews (<email>sdrews@freitagsrunde.org</email>) ==
[[Bild:SebastianDrews.jpg|thumb|150px|Sebastian Drews]]
Hallo, ich bin der Sebastian und möchte diesen sinnlosen Text demnächst gegen einen sinnvollen Text ersetzen.

 

== Sebastian Dyroff ([mailto:sdyroff@freitagsrunde.org sdyroff@freitagsrunde.org]) ==
[[Bild:SebastianDyroff.jpg|thumb|150px|Sebastian Dyroff]]
Ich studiere Informatik seit dem Wintersemester 2005/06. Zur Freitagsrunde kam ich erst etwas später: nämlich im Wintersemester 2006/07. Als erstes wurde ich damals in die Wahlliste der Freitagsrunde eingetragen. Dadurch konnte ich mich während den letzten 2 Jahren aktiv an der Unipolitik beteiligen. Natürlich habe ich mich auch an vielen anderen Aktivitäten der Freitagsrunde beteiligt. Seit 2008 bin ich Tutor des [http://www.kbs.tu-berlin.de/menue/lehre/wintersemester_200809/rechnersicherheit Praktikums Rechnersicherheit].
 

== Alexander Eichner ([mailto:alex@freitagsrunde.org alex@freitagsrunde.org]) ==
[[Bild:Alexander.jpg|thumb|150px|Alexander Eichner]]

Ich studiere seit dem Wintersemester 07/08 technische Informatik im Bachelor-Studiengang an der TU-Berlin. In der Freitagsrunde beteilige ich mich an Opalix, um auch den armen Windows-Usern das Leben im ersten Semester so einfach wie möglich zu machen ;-) und war im Wintersemester Tutor in der Einführungswoche.
Ausserdem versuche ich durch das Mitwirken in der AK den TI-Studiengang zu verbessern. Nebenbei noch als Entwickler arbeite und engagiere mich auch im Technischen Hilfswerk ([http://www.thw-oelgruppe.de]). Wenn es die Zeit erlaubt spiele ich auch Volleyball.
 

== Jannes Eilers (<email>eilers@freitagsrunde.org</email>) ==
[[Bild:JannesEilers.jpg|thumb|150px|Jannes Eilers]]
Hallo, ich bin der Jannes und möchte diesen sinnlosen Text demnächst gegen einen sinnvollen Text ersetzen.

 

== Jörg Ferdinand (<email>joerg@freitagsrunde.org</email>) ==
[[Bild:JörgFerdinand.jpg|thumb|150px|Jörg Ferdinand]]
Hallo, ich bin der Jörg und möchte diesen sinnlosen Text demnächst gegen einen sinnvollen Text ersetzen.

 

== Timo Glaser ([mailto:timo@freitagsrunde.org timo@freitagsrunde.org]) ==
[[Bild:Foto-timo.jpeg|framed|Timo Glaser]]

Im Wintersemester 2001/02 begann mein Studium der Informatik und somit meine Zeit an der TU Berlin. Damals gab es keine politische Liste an der Fakultät, die meinen Vorstellungen politischen Engagements entsprach, so dass ich mich mit einigen anderen interessierten Studierenden zusammenschloss - die Freitagsrunde war geboren ...

Jedoch konnte ich mich für zwei Jahre nicht so an der Universitätspolitik beteiligen, wie ich es gerne gewollt hätte. Nach Beendigung meines Grundstudiums nahm ich am [[Doppeldiplom SJTU | Doppeldiplomprogramm]] mit der Shanghai Jiao Tong University teil. Dies ist meiner Meinung nach eine der größten Errungenschaften der Fakultät - eine großartige Chance, die man sich nicht entgehen lassen sollte.

Im Sommer 2005 gründete ich mit vier anderen Studenten ein Unternehmen mit Fokus Wissensmanagement, die [http://www.peritor.com/ Peritor Wissensmanagement GmbH]. Da ich jedoch weiterhin wissenschaftlich arbeiten wollte und ein Thema fand, welches mich sehr faszinierte, habe ich nach Abschluss meines Studiums (Silvester 2006 ;) eine Promotion bei Professor Lutterbeck, [http://www.ig.cs.tu-berlin.de/ Informatik und Gesellschaft], begonnen. Hier, sowie in der [http://www.sysedv.tu-berlin.de/Homepage/SYSEDV.nsf?Open&Key=56QJT8&Sel&ID=3B9F9B7F8A9427A4C12570B30075790F Information Security Management Forschungsgruppe] des Systemanalyse und EDV Lehrstuhls, halte ich auch vereinzelt Vorträge im Rahmen von Lehrveranstaltungen.

Ich vertrete somit die Sichtweise der Promotionsstudierenden bzw. externen Doktoranden.
 

== Andreas Gunschl ([mailto:agunschl@mailbox.tu-berlin.de]) ==
[[Bild:AndreasGunschl.jpg|thumb|150px|Andreas Gunschl]]
Hai, ich studiere wie viele hier Informatik und interessiere mich sehr für Programmiersprachen wie Java und Groovy. Ich bin seit 7 Jahren in Berlin und eigentlich ein gebürtiger Österreicher^^. Ich bin zur Freitagsrunde gekommen weil es eine nette Bande von Leuten ist mit denen ich gerne abhänge, wissen austausche und Kicker zocke^^. Nebenbei geh ich gerne Schifahren, Radfahren und spiele manchmal Eishockey.
 

== Daniel Käs ([mailto:dkaes@cs.tu-berlin.de dkaes@cs.tu-berlin.de]) ==
[[Bild:Foto-DanielKaes.jpg|thumb|150px|Daniel Käs]]
Ich studiere Informatik seit dem WS03/04. Ich bin vor allem bei der Freitagsrunde, um anderen Studenten bei ihrem Studium zu helfen ohne mich dabei einer bestimmten politischen Gesinnung unterordnen zu müssen. Außerdem habe ich Spaß dabei andere Menschen für Informatikthemen zu begeistern, weshalb ich nicht nur bei den Javakursen, sondern auch Informationsveranstaltungen wie [[Linux-Installationsparty_2007|LIPs]] oder [[Distro-Bash_2007|Distro-Bashs]] gerne mithelfe. Neuerdings organisiere ich auch den Freitagsrunden [[TechTalk|TechTalk]].
 

== Thomas Kaschwig ([mailto:thomas@freitagsrunde.org thomas@freitagsrunde.org]) ==
[[Bild:Foto-thomas.jpeg|framed|Thomas Kaschwig]]
Ich habe an der [[TU Berlin]] [[Informatik]] studiert und arbeite nun nach Abschluss meines Studiums als [[Wissenschaftlicher Mitarbeiter]] an der [[Fakultät IV]]. Im Jahr 2002 habe ich zusammen mit einigen Kommilitonen die [[Freitagsrunde]] gegründet, da wir uns hochschulpolitisch engagieren wollten und mit den bisherigen studentischen Vertretern nicht zufrieden waren. Nach unserem Wahlsieg bei den [[Gremienwahlen 2003]] war ich für zwei Jahre Mitglied im [[Fakultätsrat]] und der [[Ausbildungskommission]]. Die letzten sechs Jahre war ich als [[Tutor]] in der [[Einführungswoche]] aktiv, die ich auch in einigen Jahre mit organisiert habe.

Seit mehr als vier Jahren bin ich Mitglied im CCT e.V. - Berlins studentischer Unternehmensberatung - und leite seit 2005 die IT-Sparte [[Juniter]]. Im Jahr 2005 habe ich mit einigen anderen Mitstreitern bei Juniter [[MeinProf.de]] gegründet, welches mittlerweile von einem eigenen Verein, dem MeinProf e.V. betrieben wird, dessen 1. Vorsitzender ich zur Zeit bin.

Erreichen könnt Ihr mich per E-Mail unter [mailto:thomas@freitagsrunde.org thomas@freitagsrunde.org].

Mails an mich kannst und solltest Du per PGP/GnuPG verschlüsseln:
<pre>
GnuPG-KeyID: 1024D/3D68D63A
Fingerprint: 274A 4CB8 B362 D593 39D6 0989 8FC3 725F 3D68 D63A
</pre>

 

== Michael Klum (michael.klum (at) mailbox.tu-berlin.de) ==
[[Bild:Foto-Michael-Klum.jpg|thumb|150px|Michael Klum]]
Ich bin sozusagen schon mein Leben lang "Vollblutbastler" und verbrenn mir auch mal gern die Finger an einem Lötkolben. Das hat mich zum Studiengang Elektrotechnik bewegt.
In der Einführungswoche für "Erstis" zum Wintersemester 2008/09 habe ich in den Raum gefragt, ob die Uni eine Möglichkeit hat zu basteln. Mir wurde gesagt ich soll mal zur Freitagsrunde kommen, und hier bin ich. Offenbar hat man die Möglichkeit von hier aus einiges ins Rollen zu bringen!

 

== Michael Kunze (<email>JaegerMFK@gmx.de</email>) ==
[[Bild:MichaelKunze.jpg|thumb|150px|Michael Kunze]]
Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Ut consectetuer, tortor ac pretium laoreet, enim lectus iaculis ante, sit amet aliquet nisl diam tempus magna. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Aliquam orci. Quisque egestas. Donec ullamcorper, pede ac ultricies venenatis, leo nisi rutrum sem, id congue nibh nisl vel nulla. Praesent id mi. Vivamus enim neque, elementum vel, elementum sed, pretium et, arcu. Curabitur leo. Etiam tristique orci viverra ligula. Nam ultricies. Donec aliquet varius elit. Maecenas massa. Nullam justo. Donec sagittis magna id lectus ultrices semper. Etiam laoreet lorem quis purus. Nam justo purus, euismod ut, porta a, eleifend id, pede. Sed tincidunt ipsum a arcu.
 

== Manuela (<email>m_h_in@gmx.de</email>) ==
[[Bild:Manuela.jpg|thumb|150px|Manuela]]
Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Ut consectetuer, tortor ac pretium laoreet, enim lectus iaculis ante, sit amet aliquet nisl diam tempus magna. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Aliquam orci. Quisque egestas. Donec ullamcorper, pede ac ultricies venenatis, leo nisi rutrum sem, id congue nibh nisl vel nulla. Praesent id mi. Vivamus enim neque, elementum vel, elementum sed, pretium et, arcu. Curabitur leo. Etiam tristique orci viverra ligula. Nam ultricies. Donec aliquet varius elit. Maecenas massa. Nullam justo. Donec sagittis magna id lectus ultrices semper. Etiam laoreet lorem quis purus. Nam justo purus, euismod ut, porta a, eleifend id, pede. Sed tincidunt ipsum a arcu.
 

== Sebastian Koch ([mailto:skoch@freitagsrunde.org skoch@freitagsrunde.org]) ==
[[Bild:skoch.jpg|thumb|150px|Sebastian Koch]]
Seit dem Wintersemester 2006/07 studiere ich Technische Informatik an der TU Berlin. Zur Freitagsrunde bin ich erst Ende des Sommersemesters 2007 gekommen. Seither habe ich an Opalix07 und Opalix08 mitgearbeitet, bei der Einführungswoche für die Studienanfänger 2007 eine Kleingruppe mit Infos versorgt und beim Eclipsekurs08 als Tutor mitgeholfen. Zudem sitze ich im Prüfungsausschuss für Technische Informatik. Für das Studium der technischen Informatik habe ich mich entschieden, da man hier das Beste aus beiden Welten (ET und Info) mitnehmen kann ;)

 

== Thaddäus Krönert ([mailto:tkroenert@freitagsrunde.org tkroenert@freitagsrunde.org]) ==
[[Bild:Thaddaeus_Kroenert.jpg|thumb|150px|Thaddäus Krönert]]
Ich bin [[Technische Informatik]]-Student seit 2007 und bin auch seit dem in der Freitagsrunde.
Ich engagiere mich fuer all das, was studieren besser macht. Auch wenn ich nicht direkt davon profitiere, so profitiere ich doch von den Ergebnissen Gleichgesinnter.

 
Im uebrigen bin ich auch, als Verfechter des amerikanischen Tastaturlayouts, gegen Umlaute!
 
 
Was ich innerhalb und außerhalb der Freitagsrunde sonst so organisiere, erfahrt ihr über [[Benutzer:Tkroenert|meine Benutzerseite]].

 

== Alexander Kührmann (<email>akuehrmann@freitagsrunde.org</email>) ==
[[Bild:11.png|thumb|150px|Alexander Kührmann]]
Hallo, ich bin der Alexander und studiere an der TUB Informatik seit dem Wintersemester 2006/2007, mittlerweile sogar schon im Master. Seit einigen Semestern versuche ich mich auch in der Freitagsrunde zu engagieren. Außerdem habe ich Spaß dabei, anderen Studis Dinge zu erklären, weshalb ich als Tutor beim Javakurs, C-Kurs und der Einführungswoche aktiv bin.

 

== Sebastian Kührmann (sebastian kuehrmann com) ==
[[Bild:SebastianKuehrmann.jpg|thumb|150px|Sebastian Kührmann]]
Hallo, ich bin der Sebastian und möchte diesen sinnlosen Text demnächst gegen einen sinnvollen Text ersetzen.

 

== Sebastian Lange (bastla -at- freitagsrunde.org) ==
[[Bild:Bastla.jpg|thumb|150px|Sebastian Lange]]

Sebastian aka bastla studiert seit dem WS2007/08 ''Technische Informatik'' an der TU-Berlin. Durch Kontakte zur Freitagsrunde nahm er schon vor Beginn des ersten Semsters an dieser Sonderform des universitären Lebens teil.

Anteil am Gesamtexperiment ''Freitagsrunde'' hat er durch die mitadministation des Freitagsrundenservers und in vertretender Stellung durch Fakultäts-politisches Engagement.

Ansonsten liegt sein Hauptengagement in der Renaissance der Amateurfunkgruppe der TU-Berlin, kurz ''AfuTUB''. Unter dem ehemals sehr bekannten Rufzeichen ''[http://dk0tu.de DK0TU]'' soll neuer studentischer Nachwuchs das Shack im obersten Stock des Hauptgebäudes betreiben.

OT Informationen auf der [[Benutzer:bastla|Benutzerseite]].

 

== Daniel Levin (dlevin (at) cs.tu-berlin.de) ==
[[Bild:Foto-Daniel-Levin.jpg|thumb|150px|Daniel Levin]]
Hello World! Ich bin Dan, der super nett und freundliche Amerikaner der Freitagsrunde. Seit 2006 bin ich Masterstudent in der Informatikrichtung hier an der TU. Bisher habe ich in Philadelphia meine Bachelorstudium in Mathematik absolviert, und ich freue mich nun hier in Berlin zu wohnen/studieren/arbeiten. I'm a Gentoo and Mac user und ich spiele gerne mit *nix Services als Sysadmin Mitarbeiter der Freitagsrunde und ich spiele gerne auch das Kartenspiel "SET". Sometimes I speak in a komische mischung von Deutsch und English. Random Facts: I can juggle. Giovanni Sollima is Amazing.
 

== Brandon Llanque (<email>brandon@freitagsrunde.org</email>) ==
[[Bild:BrandonLlanque.jpg|thumb|150px|Brandon Llanque]]
Hallo, ich bin der Brandon und möchte diesen sinnlosen Text demnächst gegen einen sinnvollen Text ersetzen.

 

== Bernd May ([mailto:bm@dv-team.de bm@dv-team.de]) ==
[[Bild:Foto-Bernd-May.jpg|thumb|150px|Bernd May]]
Ich studiere seit 2006 an der TU Informatik und hoffe, so ich das Grundstudium überstehe, mich schleunigst nach Abschluss des Bachelors an eine Vertiefung in Form des Masters of Science machen zu können.
Bei der Freitagsrunde bin ich seit Beginn meines Studiums, da ich es als wichtigen Bestandteil meiner Lehrnzeit sehe, selbst aktiv an der Gestaltung selbiger mitzuarbeiten.

Mails an mich kannst und solltest Du per PGP/GnuPG verschlüsseln:
<pre>
GnuPG-KeyID: 6EC47F94
Fingerprint: 97C5 136A 5D44 3FEF FB9B 0633 D530 0C6B 6EC4 7F94
</pre>
 

== Tibor Pilz (<email>tibor@freitagsrunde.org</email>) ==
[[Bild:TiborPilz.jpg|thumb|150px|Tibor Pilz]]
Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Ut consectetuer, tortor ac pretium laoreet, enim lectus iaculis ante, sit amet aliquet nisl diam tempus magna. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Aliquam orci. Quisque egestas. Donec ullamcorper, pede ac ultricies venenatis, leo nisi rutrum sem, id congue nibh nisl vel nulla. Praesent id mi. Vivamus enim neque, elementum vel, elementum sed, pretium et, arcu. Curabitur leo. Etiam tristique orci viverra ligula. Nam ultricies. Donec aliquet varius elit. Maecenas massa. Nullam justo. Donec sagittis magna id lectus ultrices semper. Etiam laoreet lorem quis purus. Nam justo purus, euismod ut, porta a, eleifend id, pede. Sed tincidunt ipsum a arcu.
 

== Marcel Radke ([mailto:mradke@cs.tu-berlin.de mradke@cs.tu-berlin.de]) ==
[[Bild:MRadke.JPG|thumb|150px|Marcel Radke]]
Moin. 
Seit Beginn meines Studiums im WS 07/08 hänge ich schon in der Freitagsrunde rum. Ich bin begeistert vom Tatendrang vieler Freitagsrundler und versuche selbst ein wenig meiner Kraft für ein besseres Studium einzusetzen. So war ich als Kleingruppentutor in der Einführungswoche WS 08 mit dabei und besuche auch gerne mal die AK.
Wenn ich mich ansonsten nicht gerade mit Studieren beschäftige oder vor mich hinschweige, füttere ich mein kleines Interesse für Fremdsprachen. 
soweit, man sieht sich.

 

== Xenia Spott (<email>xenia@freitagsrunde.org</email>) ==
[[Bild:XeniaSpott.jpg|thumb|150px|Xenia Spott]]
Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Ut consectetuer, tortor ac pretium laoreet, enim lectus iaculis ante, sit amet aliquet nisl diam tempus magna. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Aliquam orci. Quisque egestas. Donec ullamcorper, pede ac ultricies venenatis, leo nisi rutrum sem, id congue nibh nisl vel nulla. Praesent id mi. Vivamus enim neque, elementum vel, elementum sed, pretium et, arcu. Curabitur leo. Etiam tristique orci viverra ligula. Nam ultricies. Donec aliquet varius elit. Maecenas massa. Nullam justo. Donec sagittis magna id lectus ultrices semper. Etiam laoreet lorem quis purus. Nam justo purus, euismod ut, porta a, eleifend id, pede. Sed tincidunt ipsum a arcu.
 

== Daniel Sturm ([mailto:freitagsrunde@DanielSturm.de freitagsrunde@DanielSturm.de]) ==
[[Bild:Foto_Daniel.jpg|framed|Daniel Sturm]]
Ich habe mit dem Studium im WS03/04 begonnen und scheine damit recht gut klarzukommen. Da ich auserdem eher der Typ bin, der leicht zufriedenzustellen ist und aus dem das Beste macht was er bekommt, ist es eher unwahrscheinlich, dass ich mich aus Unzufriedenheit bei einer Studenteninitiative wie der Freitagsrunde blicken lasse. Letzeres ist eher darauf zurückzuführen, dass ich dazu geneigt bin, was zum Wohle der Allgemeinheit zu tun, sofern die Zeit es zulässt.

Alle weiteren Informationen gibts hier: http://www.dStulle.de/ oder hier: http://bog.dstulle.de/

Ich war übrigens von 2006 bis 2008 in Shanghai und habe dort am [[Doppeldiplom_SJTU|Doppeldiplomabkommen]] mit der [http://www.sjtu.edu.cn/ Shanghai Jiao Tong Universität] teilgenommen. also wer fragen dazu hat schickt mir am besten eine [mailto:sjtu@DanielSturm.de eMail].

 

== Florian Streibelt ([mailto:florian(a)freitagsrunde.org florian(a)freitagsrunde.org]) ==
[[Bild:Foto-florian.jpeg|framed|Florian Streibelt]]
Mit meinem Studium habe ich 2001 begonnen, zunächst als Elektrotechniker. Im Verlauf
des 4.Semesters habe ich dann zur Informatik gewechselt.

In der Freizeit beschäftige ich mich vor allem mit Linux, Programmieren, Netzwerk- und Computersicherheit, Elektronik und vielen anderen Themen aus dem Bereich Computer und Technik.
Ausserdem arbeite ich bei [http://www.kbs.tu-berlin.de/ KBS], mit Mitglied in der [http://www.agrs.tu-berlin.de/?id=37178 AG-Rechnersicherheit], Stellvertreter im Fakultätsrat und im AS.

Und Krawatte trage ich nicht so häufig, wie das jetzt hier den Anschein hat ;)

Mails an mich kannst und solltest Du per PGP/[http://www.gnupg.org/ GnuPG] verschlüsseln, siehe [[Benutzer:Mutax]].
 

== Bernd Weiss (<email>bweiss@freitagsrunde.org</email>) ==
[[Bild:BerndWeiss.jpg|thumb|150px|Bernd Weiss]]
Hallo, ich bin der Bernd und möchte diesen sinnlosen Text demnächst gegen einen sinnvollen Text ersetzen.

 

== Karl Wessel ([mailto:karl@freitagsrunde.org karl@freitagsrunde.org]) ==
[[Bild:karl3.jpg|thumb|150px|Karl Wessel]]
Ich habe mein Informatikstudium hier an der TU im WS04/05 begonnen, mit der Hoffnung endlich das zu lernen was ich will und wie ich es will.
Pustekuchen.
Immernoch werden 50 Prozent der Studienzeit durch ineffektive Lehrmethoden (man stelle sich ein Flasche vor die gefüllt wird indem man einen Topf über ihr ausschüttet) und Lehr-/Lernzwänge sinnlos verplämpert.
Da ich hoffe daran etwas ändern zu können bin ich nun in der Freitagsrunde.
 

== Robert Wirski (<email>wirski@freitagsrunde.org</email>) ==
[[Bild:RobertWirski.jpg|thumb|150px|Robert Wirski]]
Hallo, ich bin der Robert und möchte diesen sinnlosen Text demnächst gegen einen sinnvollen Text ersetzen.

 

'''Das sind die Mitglieder der Freitagsrunde - Zurück zu unserer [[Freitagsrunde | Selbstdefinition]].'''

(zu den [[Freitagsrunde:Ehemalige_Mitglieder|ehemaligen Mitgliedern]].)

[[Kategorie:Freitagsrunde]]

__NOTOC__
__NOEDITSECTION__

Datei:11.png

2009-12-10T18:12:41Z

Alexander Kührmann:

C-Kurs/Pong

2009-09-25T09:33:44Z

Alexander Kührmann:

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 ;)

C-Kurs/Pong/Musterlösung

2009-09-25T09:28:00Z

Alexander Kührmann: Zusatz-KI Müsterlösung

== Musterlösung ==
<pre>
#include <stdlib.h>
#include <curses.h>

/* dimensions of the field */
#define WIDTH 40
#define HEIGHT 15
#define PADDLE_HEIGHT 3

/* positions of play things */
int pos_p1_y;
int pos_p2_y;
int pos_ball_x;
int pos_ball_y;
int dir_ball_x;
int dir_ball_y;

/* scores */
int score_p1 = 0;
int score_p2 = 0;

void init() {
initscr(); /* init for curses */
noecho(); /* don't display typed chars */
cbreak(); /* don't buffer terminal lines */
keypad(stdscr, TRUE); /* for special keys (e.g. arrow keys) */
nodelay(stdscr, TRUE); /* don't block in getch() */
}

void place_paddles() {
pos_p1_y = HEIGHT / 2 - PADDLE_HEIGHT / 2;
pos_p2_y = HEIGHT / 2 - PADDLE_HEIGHT / 2;
}

void place_ball(int dir_x) {
pos_ball_x = WIDTH / 2;
pos_ball_y = HEIGHT / 2;
dir_ball_x = dir_x;
dir_ball_y = 1;
}

void print_field() {
clear();
int x,y;

/* print score */
printw(" %i %i\n", score_p1, score_p2);

/* print upper frame */
printw("+");
for(x=0; x<WIDTH; x++) {
printw("-");
}
printw("+\n");

for (y=0; y<HEIGHT; y++) {
/* first column (x==0) is for player1's paddle */
if (y >= pos_p1_y && y < pos_p1_y+PADDLE_HEIGHT) {
printw("|#");
} else if (pos_ball_x == 0 && pos_ball_y == y) {
printw("|*");
} else {
printw("| ");
}

/* middle columns (0 < x < WIDTH-1) anywhere the ball can be */
for (x=1; x<WIDTH-1; x++) {
if (y == pos_ball_y && x == pos_ball_x) {
printw("*");
} else {
printw(" ");
}
}

/* last column (x==WIDTH-1) is for player2's paddle */
if (y >= pos_p2_y && y < pos_p2_y+PADDLE_HEIGHT) {
printw("#|\n");
} else if (pos_ball_x == WIDTH-1 && pos_ball_y == y) {
printw("*|\n");
} else {
printw(" |\n");
}
}

/* print lower frame */
printw("+");
for(x=0; x<WIDTH; x++) {
printw("-");
}
printw("+\n");

refresh();
}

void key_processing() {
int ch = getch();
if (ch == KEY_UP) {
if (pos_p1_y > 0) {
pos_p1_y--;
}
} else if (ch == KEY_DOWN) {
if (pos_p1_y < HEIGHT-PADDLE_HEIGHT) {
pos_p1_y++;
}
} else if (ch == 'w') {
if (pos_p2_y > 0) {
pos_p2_y--;
}
} else if (ch == 's') {
if (pos_p2_y < HEIGHT-PADDLE_HEIGHT) {
pos_p2_y++;
}
}
}

void detect_collision() {
/* ball collides with upper/lower bounds */
if (pos_ball_y <= 0 || pos_ball_y >= HEIGHT-1) {
dir_ball_y *= -1;
}

/* ball collides with player1's paddle */
if (pos_ball_x == 1 && pos_ball_y >= pos_p1_y && pos_ball_y < pos_p1_y + PADDLE_HEIGHT) {
dir_ball_x *= -1;
}

/* ball collides with player2's paddle */
if (pos_ball_x == WIDTH-2 && pos_ball_y >= pos_p2_y && pos_ball_y < pos_p2_y + PADDLE_HEIGHT) {
dir_ball_x *= -1;
}
}

void move_ball() {
pos_ball_x += dir_ball_x;
pos_ball_y += dir_ball_y;
}

int detect_ball_out() {
/* ball is out on left side -> point for player2 */
if (pos_ball_x <= 0) {
return 2;
}

/* ball is out on right side -> point for player1 */
if (pos_ball_x >= WIDTH-1) {
return 1;
}

return 0;
}

int play_round() {
int ball_out;
int count = 0;
while( !(ball_out = detect_ball_out()) ) {
key_processing();
if(count == 0) {
move_ball();
detect_collision();
}
print_field();
count = (count + 1) % 5;
usleep(20000);
}
return ball_out;
}

int main() {
init();
place_paddles();
place_ball(1);

while(score_p1 < 10 && score_p2 < 10) {
int round_won = play_round();
if (round_won == 1) {
score_p1++;
place_ball(1);
} else if (round_won == 2) {
score_p2++;
place_ball(-1);
}
sleep(1);
flushinp(); /* keys could've been pressed during sleep -> emty the input buffer */
}

if (score_p1 > score_p2) {
printw("Player 1 wins!\n");
} else {
printw("Player 2 wins!\n");
}
refresh();
sleep(3);

endwin();
}
</pre>

== Musterlösung KI ==
Einen halbwegs ausgeglichenen Gegner bringt die folgende Lösung. Die Funktion <tt>ai_opponent</tt> muss dazu in der Schleife von <tt>play_round</tt> am besten nach <tt>key_processing</tt> aufgerufen werden.
<pre>
int can_move() {
if (dir_ball_x < 0) { /* we don't want to move when the ball departs from us */
return 0;
}
int rnd = rand();
if (pos_ball_x <= WIDTH / 4) {
rnd &= 0x1f; /* zero with probability 1/32 */
} else if (pos_ball_x <= WIDTH / 2) {
rnd &= 0x0f; /* zero with probability 1/16 */
} else if (pos_ball_x <= WIDTH * 3 / 4) {
rnd &= 0x07; /* zero with probability 1/8 */
} else {
rnd &= 0x03; /* zero with probability 1/4 */
}
return !rnd;
}

void ai_opponent() {
if (can_move()) {
int middle_pad_pos = pos_p2_y + 1;
if (pos_ball_y < middle_pad_pos) {
if (pos_p2_y > 0) {
pos_p2_y--;
}
} else if (pos_ball_y > middle_pad_pos) {
if (pos_p2_y < HEIGHT - PADDLE_HEIGHT) {
pos_p2_y++;
}
}
}
}
</pre>

== 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 ;)

C-Kurs/Pong

2009-09-22T08:49:51Z

Alexander Kührmann: /* Zusatzaufgabe: KI */

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.

== 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 -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 ;)

C-Kurs/Sammelbestellung

2009-09-21T20:22:10Z

Alexander Kührmann: Rechtschreibung gefixt

=== Aufgabenstellung ===
Diese Aufgabe soll möglichst viele Elemente der bisherigen Vorlesungen aufgreifen und verbinden. Die Teilaufgaben fangen leicht an und werden gegen Ende etwas komplexer, so dass Ihr selbst schauen könnt 'wie weit' ihr kommt. Bei Problemen nicht verzagen, Tutor fragen!

Lest Euch die Aufgabe zunächst komplett durch und überlegt, welche Datenstrukturen ihr aufbauen müsst. Macht euch auf einem Blatt Papier einen Plan, welche Funktionalitäten ihr in Funktionen ausgliedern wollt, z.B. Datensatz einfügen, suchen, entfernen, Liste ausgeben, Datei einlesen, etc. damit ihr diese Funktionen in den späteren Aufgaben einfach wieder verwenden könnt.

Die einzelnen Teilaufgaben bauen aufeinander auf und sollten daher in dieser Reihenfolge bearbeitet werden. Bearbeitet jede Teilaufgabe am besten in einem eigenen Unterverzeichnis, so dass ihr am Ende für jede Teilaufgabe eine einzelne Datei mit dem Quellcode habt.

Folgendes Szenario soll mit Hilfe von elektronischer Datenverarbeitung (kurz [[wikipedia:EDV|EDV]]) gelöst werden:

Eine Gruppe möchte zum Zweck des Sparens von Versandkosten gemeinsam bei einem Onlinehändler bestellen. Dabei soll von allen Bestellern
eine Bestellliste im CSV-Format entgegengenommen werden. Diese Einzellisten sollen dann zu einer Gesamtbestellliste zusammengeführt werden, die für jeden Artikel auflistet, wie oft er bestellt wurde. Bestellen mehrere Personen denselben Artikel, so soll dies anhand der Bestellnummer erkannt werden und dieser auf der Gesamtliste natürlich nur einmal, aber mit passender Menge, erscheinen.

Neben dieser Bestellliste soll am Ende eine kurze Liste ausgegeben werden, die angibt wie viele Produkte jeder einzelne Teilnehmer bestellt hat und wie viel Geld er bezahlen muss. Vereinfachung: Die Versandkosten sollen anhand der Menge der Artikel aufgeteilt werden, nicht nach dem Gewicht.

Im Vorfeld ist nicht bekannt, wie viele Personen insgesamt bestellen.

Beachtet die Vorgaben zu dieser Aufgabe, welche ihr hier herunterladen könnt: ..... (TODO bis Dienstag!)

=== Teil 1 ===


Erweitere die untenstehende Vorgabe so, dass jeder Aufruf der <tt>addItem()</tt>-Funktion den Artikel in einer einfach verketteten Liste speichert.

Diese Liste soll am Ende des Programms auf dem Bildschirm formatiert ausgegeben werden, nachdem alle Artikel in der Liste gespeichert sind. Dabei spielt die Reihenfolge der Ausgabe keine Rolle, es kann also sowohl an den Anfang wie an das Ende der Liste angehangen werden.

Dazu musst Du zunächst die struct-Definition der Listenelemente sinnvoll festlegen und einige Hilfsfunktionen zum Einfügen in die Liste und Ausgeben der Liste am Ende programmieren:

#include <stdlib.h>

typedef struct litem_t{
...
} litem;

typedef struct llist_t{
struct litem_t *item;
struct llist_t *next;
} llist;

llist* addItem(llist* alist, char* orderno, char* name, float price, int count, float sum){
...
}

...weitere Hilfsfunktionen ...

int main(int argc, char** argv){
...
llist *alist;
alist= addItem(NULL, "UT 2042 C","40 MHz-Digital-Speicher-Oszilloskop",349.00, 1, 349.00);
alist= addItem(alist, "AGF 2 SW","Hirschmann-Abgreifklemme 4mm schwarz",5.10,1, 5.10);
...
/* ausgeben der Liste: */
...
}

Ausgabe:
Bestellnummer Name Einzelpreis Menge Gesamtpreis
UT 2042 C 40 MHz-Digital-Speicher-Oszilloskop 349.00 1 349.00
AGF 2 SW Hirschmann-Abgreifklemme 4mm schwarz 5.10 1 5.10

=== Teil 2 ===

Schreibe ein Programm, dass eine CSV-Datei 'bestellung.csv' aus dem aktuellen Verzeichnis einliest und auf dem Bildschirm ausgibt, wie viele Artikel bestellt wurden und was diese insgesamt kosten. Das Einlesen der Datei befindet sich bereits ausprogrammiert in der Vorgabe.

Die Artikel sollen dazu zunächst in einer einfach verketteten Liste unsortiert gespeichert werden, danach soll diese Liste vom Anfang durchlaufen werden und die Artikel gezählt sowie der Preis berechnet werden.

Die CSV-Datei hat folgendes Format (Beispiele in den Vorgaben):

Bestellnummer, Kurzbeschreibung, Einzelpreis, Anzahl, Preis
UT 2042 C, 40 MHz-Digital-Speicher-Oszilloskop 349.00, 1, 349.00
AGF 2 SW, Hirschmann-Abgreifklemme 4mm schwarz 5.10,1, 5.10
AK 2 RT, Hirschmann-Krokoklemme 4mm rot 1.80, 1, 1.80

=== Teil 3 ===

Stelle nun sicher, dass ein Artikel immer nur einmal in die Liste aufgenommen werden kann. Ist er bereits in der Liste vorhanden, so soll die Anzahl und der Preis angepasst werden. Stelle außerdem sicher, dass beim Einlesen der Liste der Preis jeweils das Produkt aus Anzahl und Einzelpreis ist, und sich keine Fehler in der Bestellliste eingeschlichen haben.

Erweitere nun das Programm so, dass der Dateiname auf der Kommandozeile angegeben werden kann und so nacheinander mehrere Teilbestellungen bearbeitet werden können.

=== Teil 4 ===

Das Programm soll nun beliebig viele Dateinamen als Kommandozeilenparameter beim Start übergeben bekommen und für jeden einzelnen eine neue Liste führen. Am Ende soll dann in einem Block eine kurze, formatierte Tabelle ausgegeben werden, welche eine Spalte mit dem Dateinamen, dann die Anzahl der Produkte und den Endpreis aus der Bestellung enthält:

Dateiname Produkte Gesamtpreis
florian.csv 51 123,51
bastla.csv 12 4,12
tannek.csv 6 1,80
=====================================
SUMME: 69 129,43

Tipps: Nutze Liste von Listen, argv, argc, structs, printf, ...

=== Teil 5 ===

Erweitere das Programm jetzt schließlich so, dass nach dem kompletten Einlesen der einzelnen Listen die Gesamtbestellliste in eine Datei geschrieben wird. Dazu muss zunächst noch eine verkettete Liste angelegt werden, welche die Gesamtbestellung enthält.

Am Ende soll dann die Tabelle aus Teil 3 auf dem Bildschirm ausgeben werden und eine Datei 'gesamt.csv' im aktuellen Verzeichnis angelegt werden, welche die Gesamtbestellung enthält. Das Dateiformat ist hier exakt wie bei den einzelnen Bestelllisten.

=== Zusatzaufgabe ===

Sorge dafür, dass vor dem Beenden des Programms aller Speicher der Liste freigegeben wird. Was ist dabei zu beachten?

== 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 ;)



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

C-Kurs/(Pointer) Swapping

2009-09-21T20:11:04Z

Alexander Kührmann: Funktionsnamen formatiert

# Schreibe eine Funtion <tt>swap</tt>, die zwei Integers vertauscht. Hinweis: Du musst Zeiger auf die Integer-Variablen übergeben. Definiere zwei Integer-Variablen, gib sie auf dem Bildschirm aus, vertausche sie und gib sie erneut aus.
# Schreibe eine Funktion <tt>print_int_array</tt>, die ein Integer-Array auf dem Bildschirm ausgibt. Vertausche die Elemente zweier gleichlanger Integer-Arrays elementweise. Benutze dazu die Funktion <tt>swap</tt> aus der ersten Aufgabe. Gib die Arrays vor und nach dem Vertauschen mittels <tt>print_int_array</tt> aus.
# Schreibe nun eine Funktion <tt>swap</tt>, die zwei Integer-Pointer vertauscht.
# Benutze die Funktion <tt>swap</tt> aus 3., um zwei Integer-Arrays (nicht deren Inhalte!) zu vertauschen.
# Mache die Funktion <tt>swap</tt> aus 3. generisch, so dass sie für beliebige Typen funktioniert. Benutze hierzu void-Pointer. Teste sie zunächst mit Integer-Pointern, dann mit Integer- und Float-Arrays.

C-Kurs/Palindrome

2009-09-21T20:07:51Z

Alexander Kührmann: /* Aufgabenstellung */ Kommata

=== Einleitung ===

[[wikipedia:Palindrom|Palindrome]] sind Wörter, die rückwärts und vorwärts gleich sind, z.B. Rentner.

Später brauchst du solche Palindrome als Eingabewerte für das Programm, das du schreiben sollst. In der Wikipedia gibt es dafür eine [[wikipedia:Palindrom#Wortpalindrome|Liste mit Palindromwörtern]].

=== Aufgabenstellung ===

* Schreibe eine Funktion, die das Wort umgedreht ausgibt. Groß-/Kleinschreibung soll dabei nicht betrachtet werden. Teste deine Funktion. (Hallo => ollaH)
* Erweitere diese Funktion so, dass sie überprüft, ob ein Wort ein Palindrom ist. Teste die Funktion ausführlich.
* Schreibe nun ein Programm, welches ein Wort als Parameter von der Kommandozeile ausliest, überprüft ob dies ein Palindrom ist und eine entsprechende Meldung an den Benutzer ausgibt. Teste dein Programm ausgiebig.
* '''Für Fortgeschrittene:''' Leider kann das Programm Groß- und Kleinschreibung nicht handhaben. Am besten man konvertiert alle Zeichen zu Kleinbuchstaben. Zeichen innerhalb von Strings werden als Zahlenwerte dargestellt. 'a' hat den Wert 97 und 'A' den Wert 65, 'b' ist 98, 'B' ist 66 usw. Die Kodierung der Zeichen ist in der [http://de.wikipedia.org/wiki/Ascii#ASCII-Tabelle ASCII-Tabelle] festgehalten. Damit kann man auf den Datentyp char Rechenoperationen ausführen wie auf anderen Integertypen auch (char ist default-mäßig unsigned).
Schreibe nun eine Funktion, welche diese Kodierung nutzt, um alle Großbuchstaben in Kleinbuchstaben umzuwandeln.


[[Kategorie:CKurs]]

C-Kurs/Pong/Musterlösung

2009-09-21T19:59:52Z

Alexander Kührmann: /* Musterlösung */

== Musterlösung ==
<pre>
#include <stdlib.h>
#include <curses.h>

/* dimensions of the field */
#define WIDTH 40
#define HEIGHT 15
#define PADDLE_HEIGHT 3

/* positions of play things */
int pos_p1_y;
int pos_p2_y;
int pos_ball_x;
int pos_ball_y;
int dir_ball_x;
int dir_ball_y;

/* scores */
int score_p1 = 0;
int score_p2 = 0;

void init() {
initscr(); /* init for curses */
noecho(); /* don't display typed chars */
cbreak(); /* don't buffer terminal lines */
keypad(stdscr, TRUE); /* for special keys (e.g. arrow keys) */
nodelay(stdscr, TRUE); /* don't block in getch() */
}

void place_paddles() {
pos_p1_y = HEIGHT / 2 - PADDLE_HEIGHT / 2;
pos_p2_y = HEIGHT / 2 - PADDLE_HEIGHT / 2;
}

void place_ball(int dir_x) {
pos_ball_x = WIDTH / 2;
pos_ball_y = HEIGHT / 2;
dir_ball_x = dir_x;
dir_ball_y = 1;
}

void print_field() {
clear();
int x,y;

/* print score */
printw(" %i %i\n", score_p1, score_p2);

/* print upper frame */
printw("+");
for(x=0; x<WIDTH; x++) {
printw("-");
}
printw("+\n");

for (y=0; y<HEIGHT; y++) {
/* first column (x==0) is for player1's paddle */
if (y >= pos_p1_y && y < pos_p1_y+PADDLE_HEIGHT) {
printw("|#");
} else if (pos_ball_x == 0 && pos_ball_y == y) {
printw("|*");
} else {
printw("| ");
}

/* middle columns (0 < x < WIDTH-1) anywhere the ball can be */
for (x=1; x<WIDTH-1; x++) {
if (y == pos_ball_y && x == pos_ball_x) {
printw("*");
} else {
printw(" ");
}
}

/* last column (x==WIDTH-1) is for player2's paddle */
if (y >= pos_p2_y && y < pos_p2_y+PADDLE_HEIGHT) {
printw("#|\n");
} else if (pos_ball_x == WIDTH-1 && pos_ball_y == y) {
printw("*|\n");
} else {
printw(" |\n");
}
}

/* print lower frame */
printw("+");
for(x=0; x<WIDTH; x++) {
printw("-");
}
printw("+\n");

refresh();
}

void key_processing() {
int ch = getch();
if (ch == KEY_UP) {
if (pos_p1_y > 0) {
pos_p1_y--;
}
} else if (ch == KEY_DOWN) {
if (pos_p1_y < HEIGHT-PADDLE_HEIGHT) {
pos_p1_y++;
}
} else if (ch == 'w') {
if (pos_p2_y > 0) {
pos_p2_y--;
}
} else if (ch == 's') {
if (pos_p2_y < HEIGHT-PADDLE_HEIGHT) {
pos_p2_y++;
}
}
}

void detect_collision() {
/* ball collides with upper/lower bounds */
if (pos_ball_y <= 0 || pos_ball_y >= HEIGHT-1) {
dir_ball_y *= -1;
}

/* ball collides with player1's paddle */
if (pos_ball_x == 1 && pos_ball_y >= pos_p1_y && pos_ball_y < pos_p1_y + PADDLE_HEIGHT) {
dir_ball_x *= -1;
}

/* ball collides with player2's paddle */
if (pos_ball_x == WIDTH-2 && pos_ball_y >= pos_p2_y && pos_ball_y < pos_p2_y + PADDLE_HEIGHT) {
dir_ball_x *= -1;
}
}

void move_ball() {
pos_ball_x += dir_ball_x;
pos_ball_y += dir_ball_y;
}

int detect_ball_out() {
/* ball is out on left side -> point for player2 */
if (pos_ball_x <= 0) {
return 2;
}

/* ball is out on right side -> point for player1 */
if (pos_ball_x >= WIDTH-1) {
return 1;
}

return 0;
}

int play_round() {
int ball_out;
int count = 0;
while( !(ball_out = detect_ball_out()) ) {
key_processing();
if(count == 0) {
move_ball();
detect_collision();
}
print_field();
count = (count + 1) % 5;
usleep(20000);
}
return ball_out;
}

int main() {
init();
place_paddles();
place_ball(1);

while(score_p1 < 10 && score_p2 < 10) {
int round_won = play_round();
if (round_won == 1) {
score_p1++;
place_ball(1);
} else if (round_won == 2) {
score_p2++;
place_ball(-1);
}
sleep(1);
flushinp(); /* keys could've been pressed during sleep -> emty the input buffer */
}

if (score_p1 > score_p2) {
printw("Player 1 wins!\n");
} else {
printw("Player 2 wins!\n");
}
refresh();
sleep(3);

endwin();
}
</pre>

== 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 ;)

C-Kurs/Pong

2009-09-21T19:55:22Z

Alexander Kührmann:

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.

== 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 -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 einfache 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. Wenn sich der Schläger jetzt genauso schnell, wie der Ball, bewegen kann, wäre die KI aber nicht besiegbar. Deswegen sollte die Bewegung verlangsamt werden (z.B. indem der Schläger nur in jedem zweiten Schritt bewegt wird).

=== 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 ;)

C-Kurs/Pong

2009-09-21T19:42:26Z

Alexander Kührmann:

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.

== 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();</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 -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 einfache 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. Wenn sich der Schläger jetzt genauso schnell, wie der Ball, bewegen kann, wäre die KI aber nicht besiegbar. Deswegen sollte die Bewegung verlangsamt werden (z.B. indem der Schläger nur in jedem zweiten Schritt bewegt wird).

=== 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 ;)

C-Kurs/Studentendatenbank/Musterlösung

2009-09-21T18:00:56Z

Alexander Kührmann:

=== Musterlösung ===

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

#define ANZAHL 10
#define NAME_LEN 25

#define NAME_TO_LONG (-1)
#define MAT_NR_USED (-2)
#define DB_FULL (-3)
#define ADD_SUCCEED 1
#define NO_MAT_NR (-1)
#define DEL_SUCCEED 1

/* Teil a */
typedef struct student_t {
int mat_nr;
char first_name[NAME_LEN];
char last_name[NAME_LEN];
} student;

/* Teil b */
void print_student(student *studi) {
printf("Matr.Nr.: %i, Vorname: %s, Nachname: %s\n", studi->mat_nr, studi->first_name, studi->last_name);
}

/* Teil c */
void print_students_db(student **db) {
printf("===========================================================\n");
int i;
for (i=0; i<ANZAHL; i++) {
if (db[i] != NULL) {
print_student(db[i]);
}
}
printf("===========================================================\n");
}

/* Teil e */
void clear_db(student **db) {
int i;
for (i=0; i<ANZAHL; i++) {
if (db[i] != NULL) {
free(db[i]);
db[i] = NULL;
}
}
}

/* Teil f */
int get_student_index(int mat_nr, student **db) {
int i;
for (i=0; i<ANZAHL; i++) {
if (db[i] != NULL) {
if (mat_nr == db[i]->mat_nr) {
return i;
}
}
}
return -1;
}

int add_student(int mat_nr, char *first_name, char *last_name, student **db) {
if (strlen(first_name) >= NAME_LEN || strlen(last_name) >= NAME_LEN) {
return NAME_TO_LONG;
}
if (get_student_index(mat_nr, db) >= 0) {
return MAT_NR_USED;
}

int i;
for (i=0; i<=ANZAHL; i++) {
if (db[i] == NULL) {
db[i] = malloc(sizeof(student));
db[i]->mat_nr = mat_nr;
strcpy(db[i]->first_name, first_name);
strcpy(db[i]->last_name, last_name);
return ADD_SUCCEED;
}
}
return DB_FULL;
}

/* Teil g */
int del_student(int mat_nr, student **db) {
int del_student_index = get_student_index(mat_nr, db);
if (del_student_index < 0) {
return NO_MAT_NR;
}
free(db[del_student_index]);
db[del_student_index] = NULL;
return DEL_SUCCEED;
}

int main() {
/* Teil b*/ printf(">>> Teil b\n");
student *one_student = malloc(sizeof(student));
one_student->mat_nr = 123456;
strcpy(one_student->first_name, "Max");
strcpy(one_student->last_name, "Mustermann");
print_student(one_student);

/* Teil c */ printf(">>> Teil c\n");
student *all_students[ANZAHL];
int i;
for (i=0; i<ANZAHL; i++) {
all_students[i] = NULL;
}
all_students[0] = one_student;
print_students_db(all_students);

/* Teil d */ printf(">>> Teil d\n");
all_students[1] = malloc(sizeof(student));
all_students[1]->mat_nr=653321;
strcpy(all_students[1]->first_name, "Herbert");
strcpy(all_students[1]->last_name, "Meier");
all_students[2] = malloc(sizeof(student));
all_students[2]->mat_nr=765431;
strcpy(all_students[2]->first_name, "Hubertine");
strcpy(all_students[2]->last_name, "Schulze");
free(all_students[0]);
all_students[0] = NULL;
print_students_db(all_students);

/* Teil e */ printf(">>> Teil e\n");
clear_db(all_students);

/* Teil f */ printf(">>> Teil f\n");
if (add_student(123456, "Peter", "Mueller", all_students) == ADD_SUCCEED) {
printf("Student hinzugefuegt.\n");
}
if (add_student(123456, "Hans", "Wurst", all_students) == MAT_NR_USED) {
printf("Student nicht hinzugefuegt, da Mat.nr. schon benutzt wird.\n");
}
if (add_student(123457, "Hans", "Wurst", all_students) == ADD_SUCCEED) {
printf("Student hinzugefuegt..\n");
}
print_students_db(all_students);

/* Teil g */ printf(">>> Teil g\n");
if (del_student(123456, all_students) == DEL_SUCCEED) {
printf("Student entfernt.\n");
}
print_students_db(all_students);
}
</pre>

== 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 ;)

C-Kurs/Studentendatenbank

2009-09-21T17:53:44Z

Alexander Kührmann:

In dieser Aufgabe soll eine kleine Studentendatenbank erstellt werden.

== Aufgaben ==

=== Teil a ===
Schreibe eine Struktur <tt>student</tt>, die eine Matrikelnummer, einen Vornamen und einen Nachnamen mit jeweils passenden Datentypen enthält.

=== Teil b ===
Deklariere einen Pointer auf einen solchen Student und alloziere ihn passend. Initialisiere seine Martrikelnummer, seinen Vornamen und Nachnamen mit sinnvollen Werten.
Schreibe nun eine Funktion <tt>print_student</tt>, die einen Pointer auf einen Studenten übergeben bekommt und seine Details in einer Zeile ausgeben soll. Teste diese Funktion jetzt mit dem zuvor angelegten Studenten.

=== Teil c ===
Lege jetzt ein Array von Pointern auf Studenten der Größe 10 an. Initialisiere zunächst alle Elemente mit <tt>NULL</tt>, damit sich darin unvorhersehbaren Studenten befinden. Weise nun dem ersten Element den aus Teil b angelegten Studenten zu.
Schreibe nun einen Funktion <tt>print_students_db</tt>, die ein Pointer auf ein Array aus Studenten-Pointern übergeben bekommt, und alle Studenten ausgeben soll. Prüfe dabei, ob das jeweilige Element nicht <tt>NULL</tt> ist und benutzte dann die vorher geschriebene Funktion <tt>print_student</tt>. Wende nun die Funktion auf die Studentendatenbank an.

=== Teil d ===
Lege nun mindestens zwei weitere Studenten in der Datenbank an und lösche den ersten (dabei nicht vergessen, den Speicher wieder freizugeben). Gebe erneut die Studentendatenbank aus und überprüfe das Ergebnis.

=== Teil e ===
Am Ende wollen wir wieder aufräumen. Schreibe dazu eine Funktion <tt>clear_db</tt>, die die Studentendatenbank (wieder ein Pointer auf das Studenten-Pointer-Array) übergeben bekommt, und darin alle Einträge, die nicht <tt>NULL</tt> sind, löscht (also deren Speicher freigibt).

=== Teil f ===
Schreibe eine Funktion <tt>get_student_index</tt>, die eine Matrikelnummer und die Studentendatenbank übergeben bekommt. Sie soll die Indexposition im Array zurückgeben, an der der gesuchte Student zu finden ist. Falls es keinen Student gibt, der die Matrikelnummer hat, soll ''-1'' zurückgegeben werden.

Schreibe anschließend eine Funktion <tt>add_student</tt>, die Matrikelnummer, Vor- und Nachname des hinzuzufügenden Studenten und die Studentendatenbank übergeben bekommt. Benutzte darin die Funktion <tt>get_student_index</tt>, um sicherzustellen, dass du nicht mehrere Studenten mit derselben Matrikelnummer in der Datenbank hast. Füge den neuen Studenten im Array an der ersten Position, die <tt>NULL</tt> enthält, ein. Überlege die auch einen passenden Rückgabewert, der angibt, ob der Student erfolgreich eingefügt werden soll.

Teste die Funktion, indem du mindestens drei Studenten einfügst, von denen zwei die gleiche Matrikelnummer haben.

=== Teil g ===
Schreibe eine Funktion <tt>del_student</tt>, die eine Matrikelnummer und die Studentendatenbank übergeben bekommt. Sie soll den entsprechenden Studenten löschen. Verwende den Rückgabewert ebenfalls, um erfolgreichen Löschen anzuzeigen.

Teste die Funktion, indem du einen vorher eingefügten Studenten wieder löscht.

=== Zusatzaufgabe ===
Schreibe jetzt eine menügesteuerte Benutzerschnittstelle, die Hinzufügen und Löschen eines Studenten, und Ausgeben der kompletten Datenbank, ermöglicht.

== 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 ;)

C-Kurs/Studentendatenbank

2009-09-19T19:12:19Z

Alexander Kührmann:

C-Kurs/Pong

2009-09-19T19:08:48Z

Alexander Kührmann:

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> 1 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.

== 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>halfdelay(1);</tt> damit die Funktion, die später auf einen Tastendruck wartet, nach einer Zehntel Sekunde beendet 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 -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 Präprozessor-Befehle 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>
Durch unser bei der Initialisierung gesetztes Timeout, wird die Funktion spätestens nach 100 Millisekunden verlassen. 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> in eine Endlosschleife gepackt werden.

=== 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, und zwar praktischerweise vor <tt>move_ball</tt>. 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.

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 einfache 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. Wenn sich der Schläger jetzt genauso schnell, wie der Ball, bewegen kann, wäre die KI aber nicht besiegbar. Deswegen sollte die Bewegung verlangsamt werden (z.B. indem der Schläger nur in jedem zweiten Schritt bewegt wird).

=== 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 ;)

C-Kurs/Pong

2009-09-19T18:29:32Z

Alexander Kührmann: Tippfehler

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> 1 2
+----------------------------------------+
| |
| |
|# |
|# |
|# |
| * |
| |
| #|
| #|
| #|
| |
| |
| |
| |
| |
+----------------------------------------+</pre>

Leider ist es nicht ganz einfach, einzelne Tasten einzulesen, wie sie gebraucht werden, wenn der Benutzer den Schläger bewegen möchte. ''scanf'' 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.

== 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:
* <pre>initscr();</pre> aktiviert curses
* <pre>noecho();</pre> damit Buchstaben der getippten Tasten nicht im Terminal erscheinen
* <pre>cbreak();</pre> deaktiviert das Puffern der Terminalzeile
* <pre>keypad(stdscr, TRUE);</pre> aktiviert spezielle Tasten, wie die Pfeiltasten
* <pre>halfdelay(1);</pre> damit die Funktion, die später auf einen Tastendruck wartet, nach einer Zehntel Sekunde beendet wird

Jetzt folgt die ''main''-Funktion. Sie enthält als ersten Aufruf unsere ''init''-Funktion. Unser Programm sollte beim Beenden curses vernünftig deaktivieren, weswegen als letzter Aufruf in der ''main''-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 -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 Präprozessor-Befehle 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 ''int''. Damit wir wissen, in welche Richtung sich der Ball gerade bewegt, brauchen wir x- und -y-Richtung. Dafür eignet sich auch ''int''; 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 ''void place_paddles()'' soll die Schläger mittig platzieren. Die Funktion ''void place_ball()'' 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 ''main'' aufgerufen werden.

=== Ausgeben des Spielfelds ===
Jetzt soll die Funktion ''void print_field()'' 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 ''clear()'' von curses aufgerufen werden, was den bisherigen Terminalinhalt löscht. Wichtig ist, dass du ''printw()'' von curses statt ''printf()'' verwendest. Die Art und Weise der Verwendung ist aber identisch. Zum Schluss muss noch ''refresh()'' von curses aufgerufen werden, damit das eben ausgegebene erscheint.

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

=== Verarbeiten der Tastendrücke ===
Als nächstes kommt die Funktion ''void key_processing()'' dran. Darin fragen wir nun folgendermaßen einen Tastedruck ab:
<pre>int ch = getch();</pre>
Durch unser bei der Initialisierung gesetztes Timeout, wird die Funktion spätestens nach 100 Millisekunden verlassen. Wir können das Ergebnis in ''ch'' nun z.B. mit der Konstante ''KEY_UP'' und ''KEY_DOWN'' bzw. den Buchstaben '' 'w' '' und '' 's' '' 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 ''print_field()'' in eine Endlosschleife gepackt werden.

=== Ball bewegen ===
Schreibe jetzt die Funktion ''void move_ball()'', 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 ''void detect_collision()'' 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, und zwar praktischerweise vor ''move_ball''. 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 ''int detect_ball_out()''. 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 ''1'' bzw. für die linke Seite ''2'' zurückgeben. Ansonsten gibt die Funktion ''0'' 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 ''int play_round()'' um. Der Rückgabewert soll der Wert sein, den ''detect_ball_out()'' im Fall des Nichttreffens liefert.

In der ''main''-Funktion erstellen wir nun eine Schleife mit der Bedingung, dass beide Spieler noch weniger als 10 Punkte haben. In den Schleifenkörper kommt unser ''play_round()''; danach wird abhängig von dessen Ergebnis der Punktestand von Spieler 1 bzw. Spieler 2 inkrementiert. Dann wird der Ball mit ''place_ball'' 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 ''place_ball'' übergeben werden).

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

=== Zusatzaufgabe: KI ===
Statt des zweiten Spielers soll nun ein Computergegner spielen. Eine einfache 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. Wenn sich der Schläger jetzt genauso schnell, wie der Ball, bewegen kann, wäre die KI aber nicht besiegbar. Deswegen sollte die Bewegung verlangsamt werden (z.B. indem der Schläger nur in jedem zweiten Schritt bewegt wird).

=== 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 ''float'' 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 ;)

C-Kurs/Pong

2009-09-19T17:37:13Z

Alexander Kührmann: /* Variablen für den Zustand des Spiels */

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> 1 2
+----------------------------------------+
| |
| |
|# |
|# |
|# |
| * |
| |
| #|
| #|
| #|
| |
| |
| |
| |
| |
+----------------------------------------+</pre>

Leider ist es nicht ganz einfach, einzelne Tasten einzulesen, wie sie gebraucht werden, wenn der Benutzer den Schläger bewegen möchte. ''scanf'' 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.

== 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:
* <pre>initscr();</pre> aktiviert curses
* <pre>noecho();</pre> damit Buchstaben der getippten Tasten nicht im Terminal erscheinen
* <pre>cbreak();</pre> deaktiviert das Puffern der Terminalzeile
* <pre>keypad(stdscr, TRUE);</pre> aktiviert spezielle Tasten, wie die Pfeiltasten
* <pre>halfdelay(1);</pre> damit die Funktion, die später auf einen Tastendruck wartet, nach einer Zehntel Sekunde beendet wird

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

Wenn die Quelltextatei ''pong.c'' heißt, kann sie ab jetzt mit folgendem Befehl kompiliert werden:
<pre> gcc -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 Präprozessor-Befehle 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 ''int''. Damit wir wissen, in welche Richtung sich der Ball gerade bewegt, brauchen wir x- und -y-Richtung. Dafür eignet sich auch ''int''; 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 ''void place_paddles()'' soll die Schläger mittig platzieren. Die Funktion ''void place_ball()'' 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 ''main'' aufgerufen werden.

=== Ausgeben des Spielfelds ===
Jetzt soll die Funktion ''void print_field()'' 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 ''clear()'' von curses aufgerufen werden, was den bisherigen Terminalinhalt löscht. Wichtig ist, dass du ''printw()'' von curses statt ''printf()'' verwendest. Die Art und Weise der Verwendung ist aber identisch. Zum Schluss muss noch ''refresh()'' von curses aufgerufen werden, damit das eben ausgegebene erscheint.

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

=== Verarbeiten der Tastendrücke ===
Als nächstet kommt die Funktion ''void key_processing()'' dran. Darin fragen wir nun folgendermaßen eine Tastedruck ab:
<pre>int ch = getch();</pre>
Durch unser bei der Initialisierung gesetztes Timeout, wird die Funktion spätestens nach 100 Millisekunden verlassen. Wir können das Ergebnis in ''ch'' nun z.B. mit der Konstante ''KEY_UP'' und ''KEY_DOWN'' bzw. den Buchstaben '' 'w' '' und '' 's' '' 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 ''print_field()'' in eine Endlosschleife gepackt werden.

=== Ball bewegen ===
Schreibe jetzt die Funktion ''void move_ball()'', 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 ''void detect_collision()'' 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, und zwar praktischerweise vor ''move_ball''. 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 ''int detect_ball_out()''. 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 ''1'' bzw. für die linke Seite ''2'' zurückgeben. Ansonsten gibt die Funktion ''0'' 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 ''int play_round()'' um. Der Rückgabewert soll der Wert sein, den ''detect_ball_out()'' im Fall des Nichttreffens liefert.

In der ''main''-Funktion erstellen wir nun eine Schleife mit der Bedingung, dass beide Spieler noch weniger als 10 Punkte haben. In den Schleifenkörper kommt unser ''play_round()''; danach wird abhängig von dessen Ergebnis der Punktestand von Spieler 1 bzw. Spieler 2 inkrementiert. Dann wird der Ball mit ''place_ball'' 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 ''place_ball'' übergeben werden).

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

=== Zusatzaufgabe: KI ===
Statt des zweiten Spielers soll nun ein Computergegner spielen. Eine einfache 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. Wenn sich der Schläger jetzt genauso schnell, wie der Ball bewegen kann, wäre die KI aber nicht besiegbar. Deswegen sollte die Bewegung verlangsamt werden (z.B. indem der Schläger nur in jedem zweiten Schritt bewegt wird).

=== 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 ''float'' 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 ;)

<!--
Als kleine Starthilfe folgt ein Beispiel, wie so ein Kommentar formatiert sein könnte. Mit "Vorschau zeigen" kannst du dir ansehen, was deine Änderung bewirken würde, ohne wirklich etwas zu ändern.
Du musst übrigens außerhalb dieses auskommentieren Bereichs schreiben ;)

C-Kurs/Übungsaufgaben

2009-09-19T17:32:25Z

Alexander Kührmann: /* Die Aufgaben */

C-Kurs/Übungsaufgaben

2009-09-19T17:27:02Z

Alexander Kührmann: /* Die Aufgaben */

C-Kurs/Pong

2009-09-19T17:21:51Z

Alexander Kührmann:

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> 1 2
+----------------------------------------+
| |
| |
|# |
|# |
|# |
| * |
| |
| #|
| #|
| #|
| |
| |
| |
| |
| |
+----------------------------------------+</pre>

Leider ist es nicht ganz einfach, einzelne Tasten einzulesen, wie sie gebraucht werden, wenn der Benutzer den Schläger bewegen möchte. ''scanf'' 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.

== 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:
* <pre>initscr();</pre> aktiviert curses
* <pre>noecho();</pre> damit Buchstaben der getippten Tasten nicht im Terminal erscheinen
* <pre>cbreak();</pre> deaktiviert das Puffern der Terminalzeile
* <pre>keypad(stdscr, TRUE);</pre> aktiviert spezielle Tasten, wie die Pfeiltasten
* <pre>halfdelay(1);</pre> damit die Funktion, die später auf einen Tastendruck wartet, nach einer Zehntel Sekunde beendet wird

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

Wenn die Quelltextatei ''pong.c'' heißt, kann sie ab jetzt mit folgendem Befehl kompiliert werden:
<pre> gcc -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 Präprozessor-Befehle 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 ''int''. Damit wir wissen, in welche Richtung sich der Ball gerade bewegt, brauchen wir x- und -y-Richtung. Dafür eignet sich auch ''int''; 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 ''void place_paddles()'' soll die Schläger mittig platzieren. Die Funktion ''void place_ball()'' soll den Ball in der Mitte platzieren. Die x- und y-Reichtung können wir erstmal mit 1 belegen. Beide Funktionen sollten jetzt in der ''main'' aufgerufen werden.

=== Ausgeben des Spielfelds ===
Jetzt soll die Funktion ''void print_field()'' 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 ''clear()'' von curses aufgerufen werden, was den bisherigen Terminalinhalt löscht. Wichtig ist, dass du ''printw()'' von curses statt ''printf()'' verwendest. Die Art und Weise der Verwendung ist aber identisch. Zum Schluss muss noch ''refresh()'' von curses aufgerufen werden, damit das eben ausgegebene erscheint.

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

=== Verarbeiten der Tastendrücke ===
Als nächstet kommt die Funktion ''void key_processing()'' dran. Darin fragen wir nun folgendermaßen eine Tastedruck ab:
<pre>int ch = getch();</pre>
Durch unser bei der Initialisierung gesetztes Timeout, wird die Funktion spätestens nach 100 Millisekunden verlassen. Wir können das Ergebnis in ''ch'' nun z.B. mit der Konstante ''KEY_UP'' und ''KEY_DOWN'' bzw. den Buchstaben '' 'w' '' und '' 's' '' 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 ''print_field()'' in eine Endlosschleife gepackt werden.

=== Ball bewegen ===
Schreibe jetzt die Funktion ''void move_ball()'', 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 ''void detect_collision()'' 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, und zwar praktischerweise vor ''move_ball''. 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 ''int detect_ball_out()''. 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 ''1'' bzw. für die linke Seite ''2'' zurückgeben. Ansonsten gibt die Funktion ''0'' 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 ''int play_round()'' um. Der Rückgabewert soll der Wert sein, den ''detect_ball_out()'' im Fall des Nichttreffens liefert.

In der ''main''-Funktion erstellen wir nun eine Schleife mit der Bedingung, dass beide Spieler noch weniger als 10 Punkte haben. In den Schleifenkörper kommt unser ''play_round()''; danach wird abhängig von dessen Ergebnis der Punktestand von Spieler 1 bzw. Spieler 2 inkrementiert. Dann wird der Ball mit ''place_ball'' 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 ''place_ball'' übergeben werden).

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

=== Zusatzaufgabe: KI ===
Statt des zweiten Spielers soll nun ein Computergegner spielen. Eine einfache 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. Wenn sich der Schläger jetzt genauso schnell, wie der Ball bewegen kann, wäre die KI aber nicht besiegbar. Deswegen sollte die Bewegung verlangsamt werden (z.B. indem der Schläger nur in jedem zweiten Schritt bewegt wird).

=== 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 ''float'' 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 ;)

<!--
Als kleine Starthilfe folgt ein Beispiel, wie so ein Kommentar formatiert sein könnte. Mit "Vorschau zeigen" kannst du dir ansehen, was deine Änderung bewirken würde, ohne wirklich etwas zu ändern.
Du musst übrigens außerhalb dieses auskommentieren Bereichs schreiben ;)

C-Kurs/Übungsaufgaben

2009-09-19T16:59:48Z

Alexander Kührmann: /* Die Aufgaben */

C-Kurs/Pong/Musterlösung

2009-09-19T16:52:59Z

Alexander Kührmann: Die Seite wurde neu angelegt: „== Musterlösung == <pre> #include <curses.h> /* dimensions of the field */ #define WIDTH 40 #define HEIGHT 15 #define PADDLE_HEIGHT 3 /* positions of playing t...“

== Musterlösung ==
<pre>
#include <curses.h>

/* dimensions of the field */
#define WIDTH 40
#define HEIGHT 15
#define PADDLE_HEIGHT 3

/* positions of playing things */
int pos_p1_y;
int pos_p2_y;
int pos_ball_x;
int pos_ball_y;
int dir_ball_x;
int dir_ball_y;

/* scores */
int score_p1 = 0;
int score_p2 = 0;

void init() {
initscr(); // init for curses
noecho(); // don't display typed chars
cbreak(); // don't buffer terminal lines
keypad(stdscr, TRUE); // for special key (e.g. arrow keys)
halfdelay(1); // wait only for 1/10 s in getch()
}

void place_paddles() {
pos_p1_y = HEIGHT / 2 - PADDLE_HEIGHT / 2;
pos_p2_y = HEIGHT / 2 - PADDLE_HEIGHT / 2;
}

void place_ball(int dir_x) {
pos_ball_x = WIDTH / 2;
pos_ball_y = HEIGHT / 2;
dir_ball_x = dir_x;
dir_ball_y = 1;
}

void print_field() {
clear();
int x,y;

// print score
printw(" %i %i\n", score_p1, score_p2);

// print upper frame
printw("+");
for(x=0; x<WIDTH; x++) {
printw("-");
}
printw("+\n");

for (y=0; y<HEIGHT; y++) {
// first column (x==0) is for player1's paddle
if (y >= pos_p1_y && y < pos_p1_y+PADDLE_HEIGHT) {
printw("|#");
} else if (pos_ball_x == 0 && pos_ball_y == y) {
printw("|*");
} else {
printw("| ");
}

// middle columns (0 < x < WIDTH-1) anywhere the ball can be
for (x=1; x<WIDTH-1; x++) {
if (y == pos_ball_y && x == pos_ball_x) {
printw("*");
} else {
printw(" ");
}
}

// last column (x==WIDTH-1) is for player2's paddle
if (y >= pos_p2_y && y < pos_p2_y+PADDLE_HEIGHT) {
printw("#|\n");
} else if (pos_ball_x == WIDTH-1 && pos_ball_y == y) {
printw("*|\n");
} else {
printw(" |\n");
}
}

// print lower frame
printw("+");
for(x=0; x<WIDTH; x++) {
printw("-");
}
printw("+\n");

refresh();
}

void key_processing() {
int ch = getch();
if (ch == KEY_UP) {
if (pos_p1_y > 0) {
pos_p1_y--;
}
} else if (ch == KEY_DOWN) {
if (pos_p1_y < HEIGHT-PADDLE_HEIGHT) {
pos_p1_y++;
}
} else if (ch == 'w') {
if (pos_p2_y > 0) {
pos_p2_y--;
}
} else if (ch == 's') {
if (pos_p2_y < HEIGHT-PADDLE_HEIGHT) {
pos_p2_y++;
}
}
}

void detect_collision() {
// ball collides with upper/lower bounds
if (pos_ball_y <= 0 || pos_ball_y >= HEIGHT-1) {
dir_ball_y *= -1;
}

// ball collides with player1's paddle
if (pos_ball_x == 1 && pos_ball_y >= pos_p1_y && pos_ball_y < pos_p1_y + PADDLE_HEIGHT) {
dir_ball_x *= -1;
}

// ball collides with player2's paddle
if (pos_ball_x == WIDTH-2 && pos_ball_y >= pos_p2_y && pos_ball_y < pos_p2_y + PADDLE_HEIGHT) {
dir_ball_x *= -1;
}
}

void move_ball() {
pos_ball_x += dir_ball_x;
pos_ball_y += dir_ball_y;
}

int detect_ball_out() {
// ball is out on left side -> point for player2
if (pos_ball_x <= 0) {
return 2;
}

// ball is out on right side -> point for player1
if (pos_ball_x >= WIDTH-1) {
return 1;
}

return 0;
}

int play_round() {
int ball_out;
while( !(ball_out = detect_ball_out()) ) {
key_processing();
detect_collision();
move_ball();
print_field();
}
return ball_out;
}

int main() {
init();
place_paddles();
place_ball(1);

while(score_p1 < 10 && score_p2 < 10) {
int round_won = play_round();
if (round_won == 1) {
score_p1++;
place_ball(1);
} else if (round_won == 2) {
score_p2++;
place_ball(-1);
}
sleep(1);
}

if (score_p1 < score_p2) {
printw("Player 1 wins!\n");
} else {
printw("Player 2 wins!\n");
}
refresh();
sleep(3);

endwin();
}
</pre>

== 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 ;)

C-Kurs/Pong

2009-09-19T16:47:21Z

Alexander Kührmann: /* alles in ein rundenbasiertes Spiel stecken */

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> 1 2
+----------------------------------------+
| |
| |
|# |
|# |
|# |
| * |
| |
| #|
| #|
| #|
| |
| |
| |
| |
| |
+----------------------------------------+</pre>

Leider ist es nicht ganz einfach, einzelne Tasten einzulesen, wie sie gebraucht werden, wenn der Benutzer den Schläger bewegen möchte. ''scanf'' 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.

== 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:
* <pre>initscr();</pre> aktiviert curses
* <pre>noecho();</pre> damit Buchstaben der getippten Tasten nicht im Terminal erscheinen
* <pre>cbreak();</pre> deaktiviert das Puffern der Terminalzeile
* <pre>keypad(stdscr, TRUE);</pre> aktiviert spezielle Tasten, wie die Pfeiltasten
* <pre>halfdelay(1);</pre> damit die Funktion, die später auf einen Tastendruck wartet, nach einer Zehntel Sekunde beendet wird

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

Wenn die Quelltextatei ''pong.c'' heißt, kann sie ab jetzt mit folgendem Befehl kompiliert werden:
<pre> gcc -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 Präprozessor-Befehle 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 ''int''. Damit wir wissen, in welche Richtung sich der Ball gerade bewegt, brauchen wir x- und -y-Richtung. Dafür eignet sich auch ''int''; 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 ''void place_paddles()'' soll die Schläger mittig platzieren. Die Funktion ''void place_ball()'' soll den Ball in der Mitte platzieren. Die x- und y-Reichtung können wir erstmal mit 1 belegen. Beide Funktionen sollten jetzt in der ''main'' aufgerufen werden.

=== Ausgeben des Spielfelds ===
Jetzt soll die Funktion ''void print_field()'' 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 ''clear()'' von curses aufgerufen werden, was den bisherigen Terminalinhalt löscht. Wichtig ist, dass du ''printw()'' von curses statt ''printf()'' verwendest. Die Art und Weise der Verwendung ist aber identisch. Zum Schluss muss noch ''refresh()'' von curses aufgerufen werden, damit das eben ausgegebene erscheint.

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

=== Verarbeiten der Tastendrücke ===
Als nächstet kommt die Funktion ''void key_processing()'' dran. Darin fragen wir nun folgendermaßen eine Tastedruck ab:
<pre>int ch = getch();</pre>
Durch unser bei der Initialisierung gesetztes Timeout, wird die Funktion spätestens nach 100 Millisekunden verlassen. Wir können das Ergebnis in ''ch'' nun z.B. mit der Konstante ''KEY_UP'' und ''KEY_DOWN'' bzw. den Buchstaben '' 'w' '' und '' 's' '' 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 ''print_field()'' in eine Endlosschleife gepackt werden.

=== Ball bewegen ===
Schreibe jetzt die Funktion ''void move_ball()'', 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 ''void detect_collision()'' 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, und zwar praktischerweise vor ''move_ball''. 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 ''int detect_ball_out()''. 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 ''1'' bzw. für die linke Seite ''2'' zurückgeben. Ansonsten gibt die Funktion ''0'' 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 ''int play_round()'' um. Der Rückgabewert soll der Wert sein, den ''detect_ball_out()'' im Fall des Nichttreffens liefert.

In der ''main''-Funktion erstellen wir nun eine Schleife mit der Bedingung, dass beide Spieler noch weniger als 10 Punkte haben. In den Schleifenkörper kommt unser ''play_round()''; danach wird abhängig von dessen Ergebnis der Punktestand von Spieler 1 bzw. Spieler 2 inkrementiert. Dann wird der Ball mit ''place_ball'' 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 ''place_ball'' übergeben werden).

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

== 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 ;)

<!--
Als kleine Starthilfe folgt ein Beispiel, wie so ein Kommentar formatiert sein könnte. Mit "Vorschau zeigen" kannst du dir ansehen, was deine Änderung bewirken würde, ohne wirklich etwas zu ändern.
Du musst übrigens außerhalb dieses auskommentieren Bereichs schreiben ;)

C-Kurs/Pong

2009-09-19T16:41:51Z

Alexander Kührmann: /* alles in ein rundenbasiertes Spiel stecken */

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> 1 2
+----------------------------------------+
| |
| |
|# |
|# |
|# |
| * |
| |
| #|
| #|
| #|
| |
| |
| |
| |
| |
+----------------------------------------+</pre>

Leider ist es nicht ganz einfach, einzelne Tasten einzulesen, wie sie gebraucht werden, wenn der Benutzer den Schläger bewegen möchte. ''scanf'' 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.

== 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:
* <pre>initscr();</pre> aktiviert curses
* <pre>noecho();</pre> damit Buchstaben der getippten Tasten nicht im Terminal erscheinen
* <pre>cbreak();</pre> deaktiviert das Puffern der Terminalzeile
* <pre>keypad(stdscr, TRUE);</pre> aktiviert spezielle Tasten, wie die Pfeiltasten
* <pre>halfdelay(1);</pre> damit die Funktion, die später auf einen Tastendruck wartet, nach einer Zehntel Sekunde beendet wird

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

Wenn die Quelltextatei ''pong.c'' heißt, kann sie ab jetzt mit folgendem Befehl kompiliert werden:
<pre> gcc -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 Präprozessor-Befehle 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 ''int''. Damit wir wissen, in welche Richtung sich der Ball gerade bewegt, brauchen wir x- und -y-Richtung. Dafür eignet sich auch ''int''; 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 ''void place_paddles()'' soll die Schläger mittig platzieren. Die Funktion ''void place_ball()'' soll den Ball in der Mitte platzieren. Die x- und y-Reichtung können wir erstmal mit 1 belegen. Beide Funktionen sollten jetzt in der ''main'' aufgerufen werden.

=== Ausgeben des Spielfelds ===
Jetzt soll die Funktion ''void print_field()'' 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 ''clear()'' von curses aufgerufen werden, was den bisherigen Terminalinhalt löscht. Wichtig ist, dass du ''printw()'' von curses statt ''printf()'' verwendest. Die Art und Weise der Verwendung ist aber identisch. Zum Schluss muss noch ''refresh()'' von curses aufgerufen werden, damit das eben ausgegebene erscheint.

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

=== Verarbeiten der Tastendrücke ===
Als nächstet kommt die Funktion ''void key_processing()'' dran. Darin fragen wir nun folgendermaßen eine Tastedruck ab:
<pre>int ch = getch();</pre>
Durch unser bei der Initialisierung gesetztes Timeout, wird die Funktion spätestens nach 100 Millisekunden verlassen. Wir können das Ergebnis in ''ch'' nun z.B. mit der Konstante ''KEY_UP'' und ''KEY_DOWN'' bzw. den Buchstaben '' 'w' '' und '' 's' '' 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 ''print_field()'' in eine Endlosschleife gepackt werden.

=== Ball bewegen ===
Schreibe jetzt die Funktion ''void move_ball()'', 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 ''void detect_collision()'' 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, und zwar praktischerweise vor ''move_ball''. 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 ''int detect_ball_out()''. 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 ''1'' bzw. für die linke Seite ''2'' zurückgeben. Ansonsten gibt die Funktion ''0'' 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 ''int play_round()'' um. Der Rückgabewert soll der Wert sein, den ''detect_ball_out()'' im Fall des Nichttreffens liefert.

In der ''main''-Funktion erstellen wir nun eine Schleife mit der Bedingung, dass beide Spieler noch weniger als 10 Punkte haben. In den Schleifenkörper kommt unser ''play_round()''; danach wird abhängig von dessen Ergebnis der Punktestand von Spieler 1 bzw. Spieler 2 inkrementiert.

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

== 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 ;)

<!--
Als kleine Starthilfe folgt ein Beispiel, wie so ein Kommentar formatiert sein könnte. Mit "Vorschau zeigen" kannst du dir ansehen, was deine Änderung bewirken würde, ohne wirklich etwas zu ändern.
Du musst übrigens außerhalb dieses auskommentieren Bereichs schreiben ;)

C-Kurs/Pong

2009-09-19T16:32:30Z

Alexander Kührmann: /* Erkennen, wenn der Ball nicht vom Schläger getroffen wurde */

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> 1 2
+----------------------------------------+
| |
| |
|# |
|# |
|# |
| * |
| |
| #|
| #|
| #|
| |
| |
| |
| |
| |
+----------------------------------------+</pre>

Leider ist es nicht ganz einfach, einzelne Tasten einzulesen, wie sie gebraucht werden, wenn der Benutzer den Schläger bewegen möchte. ''scanf'' 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.

== 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:
* <pre>initscr();</pre> aktiviert curses
* <pre>noecho();</pre> damit Buchstaben der getippten Tasten nicht im Terminal erscheinen
* <pre>cbreak();</pre> deaktiviert das Puffern der Terminalzeile
* <pre>keypad(stdscr, TRUE);</pre> aktiviert spezielle Tasten, wie die Pfeiltasten
* <pre>halfdelay(1);</pre> damit die Funktion, die später auf einen Tastendruck wartet, nach einer Zehntel Sekunde beendet wird

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

Wenn die Quelltextatei ''pong.c'' heißt, kann sie ab jetzt mit folgendem Befehl kompiliert werden:
<pre> gcc -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 Präprozessor-Befehle 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 ''int''. Damit wir wissen, in welche Richtung sich der Ball gerade bewegt, brauchen wir x- und -y-Richtung. Dafür eignet sich auch ''int''; 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 ''void place_paddles()'' soll die Schläger mittig platzieren. Die Funktion ''void place_ball()'' soll den Ball in der Mitte platzieren. Die x- und y-Reichtung können wir erstmal mit 1 belegen. Beide Funktionen sollten jetzt in der ''main'' aufgerufen werden.

=== Ausgeben des Spielfelds ===
Jetzt soll die Funktion ''void print_field()'' 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 ''clear()'' von curses aufgerufen werden, was den bisherigen Terminalinhalt löscht. Wichtig ist, dass du ''printw()'' von curses statt ''printf()'' verwendest. Die Art und Weise der Verwendung ist aber identisch. Zum Schluss muss noch ''refresh()'' von curses aufgerufen werden, damit das eben ausgegebene erscheint.

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

=== Verarbeiten der Tastendrücke ===
Als nächstet kommt die Funktion ''void key_processing()'' dran. Darin fragen wir nun folgendermaßen eine Tastedruck ab:
<pre>int ch = getch();</pre>
Durch unser bei der Initialisierung gesetztes Timeout, wird die Funktion spätestens nach 100 Millisekunden verlassen. Wir können das Ergebnis in ''ch'' nun z.B. mit der Konstante ''KEY_UP'' und ''KEY_DOWN'' bzw. den Buchstaben '' 'w' '' und '' 's' '' 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 ''print_field()'' in eine Endlosschleife gepackt werden.

=== Ball bewegen ===
Schreibe jetzt die Funktion ''void move_ball()'', 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 ''void detect_collision()'' 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, und zwar praktischerweise vor ''move_ball''. 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 ''int detect_ball_out()''. 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 ''1'' bzw. für die linke Seite ''2'' zurückgeben. Ansonsten gibt die Funktion ''0'' 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 ===

== 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 ;)

<!--
Als kleine Starthilfe folgt ein Beispiel, wie so ein Kommentar formatiert sein könnte. Mit "Vorschau zeigen" kannst du dir ansehen, was deine Änderung bewirken würde, ohne wirklich etwas zu ändern.
Du musst übrigens außerhalb dieses auskommentieren Bereichs schreiben ;)

C-Kurs/Pong

2009-09-19T16:25:39Z

Alexander Kührmann: /* Kollisionen des Balls erkennen */

C-Kurs/Pong

2009-09-19T16:16:44Z

Alexander Kührmann:

C-Kurs/Pong

2009-09-19T16:11:12Z

Alexander Kührmann:

C-Kurs/Pong

2009-09-19T15:57:29Z

Alexander Kührmann:

C-Kurs/Pong

2009-09-19T15:38:51Z

Alexander Kührmann:

C-Kurs/Pong

2009-09-19T15:17:29Z

Alexander Kührmann: Die Seite wurde neu angelegt: „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 ein...“

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.

Leider ist es nicht ganz einfach, einzelne Tasten einzulesen, wie sie gebraucht werden, wenn der Benutzer den Schläger bewegen möchte. ''scanf'' 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.

== 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:
* <pre>initscr();</pre> aktiviert curses
* <pre>noecho();</pre> damit Buchstaben der getippten Tasten nicht im Terminal erscheinen
* <pre>cbreak();</pre> deaktiviert das Puffern der Terminalzeile
* <pre>keypad(stdscr, TRUE);</pre> aktiviert spezielle Tasten, wie die Pfeiltasten
* <pre>halfdelay(1);</pre> damit die Funktion, die später auf einen Tastendruck wartet, nach einer Zehntel Sekunde beendet wird

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

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

=== Variablen für den Zustand des Spiels ===

=== Ausgeben des Spielfelds ===

=== Verarbeiten der Tastendrücke ===

=== Kollisionen des Balls erkennen ===

=== Erkennen, wenn der Ball nicht vom Schläger getroffen wurde ===

=== alles in ein rundenbasiertes Spiel stecken ===

== 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 ;)

<!--
Als kleine Starthilfe folgt ein Beispiel, wie so ein Kommentar formatiert sein könnte. Mit "Vorschau zeigen" kannst du dir ansehen, was deine Änderung bewirken würde, ohne wirklich etwas zu ändern.
Du musst übrigens außerhalb dieses auskommentieren Bereichs schreiben ;)

C-Kurs/Studentendatenbank

2009-09-19T14:32:23Z

Alexander Kührmann: /* Teil c */

In dieser Aufgabe soll eine kleine Studentendatenbank erstellt werden.

== Aufgaben ==

=== Teil a ===
Schreibe eine Struktur ''student'', die eine Matrikelnummer, einen Vornamen und einen Nachnamen mit jeweils passenden Datentypen enthält.

=== Teil b ===
Deklariere einen Pointer auf einen solchen Student und alloziere ihn passend. Initialisiere seine Matrikelnummenr, seinen Vornamen und Nachnamen mit sinnvollen Werten.
Schreibe nun eine Funktion ''print_student'', die einen Pointer auf einen Studenten übergeben bekommt und seine Details in einer Zeile ausgeben soll. Teste diese Funktion jetzt mit dem zuvor angelegten Student.

=== Teil c ===
Lege jetzt ein Array von Pointern auf Studenten der Größe 10 an. Initialisiere zunächst alle Elemente mit ''NULL'', damit sich darin unvorhersehbaren Studenten befinden. Weise nun dem ersten Element den aus Teil b angelegten Studenten zu.
Schreibe nun einen Funktion ''print_studenten_db'', die ein Pointer auf ein Array aus Studenten-Pointern übergeben bekommt, und alle Studenten ausgeben soll. Prüfe dabei, ob das jeweilige Element nicht ''NULL'' ist und benutzte dann die vorher geschriebene Funktion ''print_student''. Wende nun die Funktion auf die Studentendatenbank an.

=== Teil d ===
Lege nun mindestens zwei weitere Studenten in der Datenbank an und lösche den ersten (dabei nicht vergessen, den Speicher wieder freizugeben). Gebe erneut die Studentendatenbank aus und überprüfe das Ergebnis.

=== Teil e ===
Am Ende wollen wir wieder aufräumen. Schreibe dazu eine Funktion ''clear_db'', die die Studentendatenbank (wieder ein Pointer auf das Studenten-Pointer-Array) übergeben bekommt, und darin alle Einträge, die nicht ''NULL'' sind, löscht (also deren Speicher freigibt).

== 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 ;)

<!--
Als kleine Starthilfe folgt ein Beispiel, wie so ein Kommentar formatiert sein könnte. Mit "Vorschau zeigen" kannst du dir ansehen, was deine Änderung bewirken würde, ohne wirklich etwas zu ändern.
Du musst übrigens außerhalb dieses auskommentieren Bereichs schreiben ;)

C-Kurs/Übungsaufgaben

2009-09-19T13:21:29Z

Alexander Kührmann: /* Die Aufgaben */

C-Kurs/Studentendatenbank

2009-09-19T13:15:35Z

Alexander Kührmann:

In dieser Aufgabe soll eine kleine Studentendatenbank erstellt werden.

== Aufgaben ==

=== Teil a ===
Schreibe eine Struktur ''student'', die eine Matrikelnummer, einen Vornamen und einen Nachnamen mit jeweils passenden Datentypen enthält.

=== Teil b ===
Deklariere einen Pointer auf einen solchen Student und alloziere ihn passend. Initialisiere seine Matrikelnummenr, seinen Vornamen und Nachnamen mit sinnvollen Werten.
Schreibe nun eine Funktion ''print_student'', die einen Pointer auf einen Studenten übergeben bekommt und seine Details in einer Zeile ausgeben soll. Teste diese Funktion jetzt mit dem zuvor angelegten Student.

=== Teil c ===
Lege jetzt ein Array von Pointern auf Studenten der Größe 10 an. Initialisiere zunächst alle Elemente mit ''NULL'', damit sich darin unvorhersehbaren Studenten befinden. Weise nun dem ersten Element den aus Teil b angelegten Studenten zu.
Schreibe nun einen Funktion ''print_studenten_db'', die ein Pointer auf ein Array aus Studenten-Pointern übergeben bekommt, und alle Studenten ausgeben soll. Prüfe dabei, ob das jeweilige Element nicht ''NULL'' ist und benutzte dann die vorher geschriebene Funktion 'print_student''. Wende nun die Funktion auf die Studentendatenbank an.

=== Teil d ===
Lege nun mindestens zwei weitere Studenten in der Datenbank an und lösche den ersten (dabei nicht vergessen, den Speicher wieder freizugeben). Gebe erneut die Studentendatenbank aus und überprüfe das Ergebnis.

=== Teil e ===
Am Ende wollen wir wieder aufräumen. Schreibe dazu eine Funktion ''clear_db'', die die Studentendatenbank (wieder ein Pointer auf das Studenten-Pointer-Array) übergeben bekommt, und darin alle Einträge, die nicht ''NULL'' sind, löscht (also deren Speicher freigibt).

== 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 ;)

<!--
Als kleine Starthilfe folgt ein Beispiel, wie so ein Kommentar formatiert sein könnte. Mit "Vorschau zeigen" kannst du dir ansehen, was deine Änderung bewirken würde, ohne wirklich etwas zu ändern.
Du musst übrigens außerhalb dieses auskommentieren Bereichs schreiben ;)

C-Kurs/Studentendatenbank/Musterlösung

2009-09-19T13:14:23Z

Alexander Kührmann: Die Seite wurde neu angelegt: „=== Musterlösung === <pre> #include <stdlib.h> #include <stdio.h> #include <string.h> #define ANZAHL 10 /* Teil a */ struct student { int mat_nr; char vorna...“

=== Musterlösung ===

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

#define ANZAHL 10

/* Teil a */
struct student {
int mat_nr;
char vorname[25];
char nachname[25];
};

/* Teil b */
print_student(struct student *studi) {
printf("Matr.Nr.: %i, Vorname: %s, Nachname: %s\n", studi->mat_nr, studi->vorname, studi->nachname);
}

/* Teil c */
print_studenten_db(struct student **db) {
int i;
for (i=0; i<ANZAHL; i++) {
if (db[i] != NULL) {
print_student(db[i]);
}
}
}

/* Teil e */
clear_db(struct student **db) {
int i;
for (i=0; i<ANZAHL; i++) {
if (db[i] != NULL) {
free(db[i]);
db[i] = NULL;
}
}
}

int main() {
/* Teil b*/ printf("Teil b\n");
struct student *ein_student = malloc(sizeof(struct student));
ein_student->mat_nr = 123456;
strcpy(ein_student->vorname, "Max");
strcpy(ein_student->nachname, "Mustermann");
print_student(ein_student);

/* Teil c */ printf("Teil c\n");
struct student *alle_studenten[ANZAHL];
int i;
for (i=0; i<ANZAHL; i++) {
alle_studenten[i] = NULL;
}
alle_studenten[0] = ein_student;
print_studenten_db(alle_studenten);

/* Teil d */ printf("Teil d\n");
alle_studenten[1] = malloc(sizeof(struct student));
alle_studenten[1]->mat_nr=653321;
strcpy(alle_studenten[1]->vorname, "Herbert");
strcpy(alle_studenten[1]->nachname, "Meier");
alle_studenten[2] = malloc(sizeof(struct student));
alle_studenten[2]->mat_nr=765431;
strcpy(alle_studenten[2]->vorname, "Hubertine");
strcpy(alle_studenten[2]->nachname, "Schulze");
free(alle_studenten[0]);
alle_studenten[0] = NULL;
print_studenten_db(alle_studenten);

/* Teil e */
clear_db(alle_studenten);
}
</pre>

== 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 ;)

<!--
Als kleine Starthilfe folgt ein Beispiel, wie so ein Kommentar formatiert sein könnte. Mit "Vorschau zeigen" kannst du dir ansehen, was deine Änderung bewirken würde, ohne wirklich etwas zu ändern.
Du musst übrigens außerhalb dieses auskommentieren Bereichs schreiben ;)

C-Kurs/Studentendatenbank

2009-09-19T13:10:49Z

Alexander Kührmann: Die Seite wurde neu angelegt: „In dieser Aufgabe soll eine kleine Studentendatenbank erstellt werden. == Aufgaben == === Teil a === Schreibe eine Struktur ''student'', die eine Matrikelnummer...“

In dieser Aufgabe soll eine kleine Studentendatenbank erstellt werden.

== Aufgaben ==

=== Teil a ===
Schreibe eine Struktur ''student'', die eine Matrikelnummer, einen Vornamen und einen Nachnamen mit jeweils passenden Datentypen enthält.

=== Teil b ===
Deklariere einen Pointer auf einen solchen Student und alloziere ihn passend. Initialisiere seine Matrikelnummenr, seinen Vornamen und Nachnamen mit sinnvollen Werten.
Schreibe nun eine Funktion ''print_student'', die einen Pointer auf einen Studenten übergeben bekommt und seine Details in einer Zeile ausgeben soll. Teste diese Funktion jetzt mit dem zuvor angelegten Student.

=== Teil c ===
Lege jetzt ein Array von Pointern auf Studenten der Größe 10 an. Initialisiere zunächst alle Elemente mit ''NULL'', damit sich darin unvorhersehbaren Studenten befinden. Weise nun dem ersten Element den aus Teil b angelegten Studenten zu.
Schreibe nun einen Funktion ''print_studenten_db'', die ein Pointer auf ein Array aus Studenten-Pointern übergeben bekommt, und alle Studenten ausgeben soll. Prüfe dabei, ob das jeweilige Element nicht ''NULL'' ist und benutzte dann die vorher geschriebene Funktion 'print_student''. Wende nun die Funktion auf die Studentendatenbank an.

=== Teil d ===
Lege nun mindestens zwei weitere Studenten in der Datenbank an und lösche den ersten (dabei nicht vergessen, den Speicher wieder freizugeben). Gebe erneut die Studentendatenbank aus und überprüfe das Ergebnis.

=== Teil e ===
Am Ende wollen wir wieder aufräumen. Schreibe dazu eine Funktion ''clear_db'', die die Studentendatenbank (wieder ein Pointer auf das Studenten-Pointer-Array) übergeben bekommt, und darin alle Einträge, die nicht ''NULL'' sind, löscht (also deren Speicher freigibt).