Willkommen zur zweiten Lektion der Programmierschule!
Jetzt coden wir mal ein bisschen!
Diese Lektion ist diesmal ein wenig länger, macht also zwischendrin Pausen.

Inhalt

1. Das Grundgerüst
2. Variablen
3. if und else
4. Funktionen
5. Lokale und globale Variablen
6. Hausaufgaben Lektion 2


1. Das Grundgerüst

Bevor wir anfangen zu coden, müsst ihr erst einmal etwas über den Compiler wissen:
Beim Compilieren liest dieser unseren Code von oben nach unten und die einzelnen Zeilen von links nach rechts, also genau so wie auch wir einen Text durchlesen.
Das klingt einfach, aber es ist extrem wichtig für das spätere Coden. A7 hat auch noch einen Debugger eingebaut, das heisst, die Engine (= "Maschine", sozusagen der Compiler)
übersetzt den Code nicht nur, sondern durchsucht diesen auch nach Fehlern. Wie das genau funktioniert sehen wir später. Genug geredet, fangen wir an.

Startet SED und öffnet einen leeren Script, falls es das nicht schon automatisch gemacht hat.
Zuallererst speichern wir unseren leeren Script ab, sonst motzt der Compiler. Drückt dazu auf "save" unter "file" oder drückt auf das Kasettensymbol.
Im Speichermenü geht ihr in den GS-Ordner. (Programme/GStdio7) Dort sollte sich der Ordner "Work" befinden. Wenn ihr ihn in der ersten Lektion noch nicht erstellt habt, tut das jetzt.
Erstellt nun noch einen Ordner, diesmal mit dem Projektnamen. Wir nennen es schlicht und einfach "lektion_2". Darin speichern wir unseren Script ebenfalls mit dem Namen lektion_2, aber mit einem ".c".
also so: "lektion_2.c". "c" ist die Dateiendung für einen Script in Lite-C. Manche haben auch die Endung ".wdl" aber dazu kommen wir in einer anderen Lektion.
Anbei solltet ihr euch angewöhnen, in Zukunft alle Dateien so zu nennen, dass der Name keine Leerzeichen oder Grossschreibung enthält. Das beugt unnötigen Problemen vor.
Achtet ebenfalls darauf, euren Code, bevor ihr ihn ausführt, immer abzuspeichern.

Jetzt können wir anfangen zu coden!

Schreibt an den Anfang vom Script folgende Zeilen, dann sag ich euch, was diese bewirken:



#include ist englisch und bedeutet "einbinden", und das ist genau das, was dieser Befehl macht; Er bindet andere Scripts in unser Script ein.
Ein ganzes Computerspiel benötigt nämlich gerne mal über 10000 Zeilen Code, was auf einen einzelnen Script ein wenig unübersichtlich wäre.
Also teilt man das Ganze auf mehrere Scripts auf. Eines nennt man z.B. "player.c", dort schreibt man alle Befehle für den Hauptspieler rein,
oder "enemies.c" enthält die Befehle für die Feinde etc. aber ihr seid bei der Namensgebung eurer Scripts völlig frei.
Hier werden jedenfalls zwei Scripts vom Ordner "include" im GS-Ordner eingebunden.
acknex.h ist die Engine, sie enthält alle Funktionen von Lite-C. Dies muss umbedingt in jedem Projekt eingebunden sein.
default.c wird hingegen meist nach der Vervollständigung eines Projekts gelöscht. Dort sind die Funktionen enthalten, welche bewirken,
dass man das Programm nachher mit esc beenden kann, oder dass man Variabeln manuell eingeben kann, etc.

Nun haben wir eigentlich schon unser erstes Programm geschrieben. Testen wir es doch mal aus.
Speichert dazu euren script mit "save" oder Strg+S und klickt dann auf das violette Dreieck in der Navigationsleiste namens "Test run".
Dann sollte sich kurz ein rötliches Fenster öffnen und dann ein schwarzes Fenster. Das ist unser Programm. ^^
Ich weiss, sieht noch nicht sehr atemberaubend aus, aber wir haben auch noch nicht sonderlich viel dafür gemacht.
Beendet nun das Programm mit Esc, damit wir das Ganze ein wenig spannender gestalten können.

Nun können wir aber nicht einfach nur Befehle in den Script reinschreiben, das würde eine Fehlermeldung geben.
Alle Befehle müssen in Funktionen eingebunden werden, nur Definitionen nicht. Aber dazu kommen wir später.
Wir brauchen jedenfalls eine Hauptfunktion in unserem Script. Diese ist schon vorgefertigt und heisst "main", das ist englisch und bedeutet "haupt/wichtigstes".
Zu funktionen kommen wir aber wie gesagt später, schreibt also folgendes:



Diese Funktion wird direkt beim Start des Programms automatisch ausgeführt. Hier rein können wir ersteinmal unsere Befehle schreiben.
Aber nicht vergessen, dass der Compiler von oben nach unten liest, also müssen wir auch in diese Funktion von oben nach unten die Befehle eingeben.
Als Erstes formatieren wir das Anzeigefenster. Es gibt viele verschiede Arten, die kürzeste ist mit video_set und video_window.
video_set verändert die auflösung und video_window das Anzeigefenster.
Wir verändern zuerst die Auflösung, dann das Fenster. Umgekehrt würde sich die das Fenster nicht der Auflösung anpassen und das sieht hässlich aus.
Schreibt jedenfalls mal in die Mainfunktion "video_set", das färbt sich dann rot und ihr seht in der "Command help" (untere Leiste) was dieser Befehl macht, wie ihr ihn anwendet etc..
Folgender Text ist wichtig für uns:

Der Aufbau der Funktion:
video_set(var width,var height,var depth,var screen)

Und die Beschreibung darunter:
Die Anweisung arbeitet wie video_switch, nur das Sie hier die Breite und Höhe individuell einstellen können. Auf diese Weise ist die einzustellende Auflösung beliebig, und nicht auf die 12 unterstützten beschränkt.

Sowie die Parameter, welche sich auf den Aufbau der Funktion beziehen:
width: Breite von Bildschirm bzw. Fenster oder 0 bei keiner Änderung.
height: Höhe von Bildschirm bzw. Fenster oder 0 bei keiner Änderung.
depth: immer 0
screen: Vollbild (1) oder Window-Modus (2) oder 0 bei keiner Änderung.

Und schon wissen wir, wie dieser Befehl funktioniert.
Wir wollen eine Fensterlänge und eine Fensterbreite von 800.
Jetzt müssen wir das nur noch einsetzen und wir bekommen das:



wir machen nun das Gleiche bei "video_window". Gebt es im Scripteditor ein und schaut wieder in die "Command help".
Wir wollen keine Positionsänderung, eine Fenstergrösse von vector(800,800,0) (Vektoren besprechen wir erst später), ohne Rahmen und mit dem titel "Lektion 2". (Strings besprechen wir ebenfalls später)
Wenn wir alles einsetzen, bekommen wir das:



Jetzt schreiben wir diese beiden Befehle in der richtigen Reihenfolge in unsere Mainfunktion.
Das sollte jetzt so aussehen:



Nun wollen wir mal schauen, ob das Ganze funktioniert. Drückt dazu wieder auf den "Test run"-Button, natürlich anchdem ihr euren Script gespeichert habt.
Doch was ist das?



Wir haben wohl etwas falsch gemacht. Und der Compiler bzw. der darin enthaltene Debugger ist sogar so nett und sagt uns, wo, nämlich zumindest bei mir in Zeile 10. (Ich habe noch Absätze drin, bei euch ist es vermutlich eine andere Zeile)
Drückt das Fenster mit Esc weg und begutachtet die anscheinend falsche Zeile. Wir haben gerade einen typischen Anfängerfehler gemacht. Hinter jede Befehlszeile kommt nämlich ein Semikolon, damit der Compiler weiss, dass hier eine Zeile fertig ist. So gut wie alle Befehle, auf die keine geschweiften Klammern folgen, benötigen so eines. Das würde dann so aussehen:


speichert es und drückt nochmals auf "Test run", und ihr seht, es funktioniert. (Ausser ihr habt noch was Anderes falsch gemacht)

Rein theoretisch könnte man also ein ganzes Programm in eine einzige Zeile schreiben.
Das hier würde z.B. für den Compiler das Gleiche bedeuten:



Es ist einfach unübersichtlicher.


Ihr werdet bestimmt bemerkt haben, dass uns der Debugger eigentlich eine falsche Zeile angegeben hat, nämlich die mit video_window und nicht die mit video_set, obwohl auch bei video_set ein Semikolon fehlte.
Aber das hat einen einfachen Grund: Der Debugger bemerkt einen Fehler erst, wenn etwas keinen Sinn mehr für ihn ergibt.
In unserem Fall hat er zuerst das hier gelesen:

Daran ist soweit auch nichts falsch, erst wenn er zur nächsten Zeile kommt, erhält er dieses für ihn "sinnlose" Konstrukt:

Und dann sagt er uns, dass bei video_window etwas nicht stimmt.
Würden wir also hingegen den Befehl selbst falsch schreiben, würde er uns die richtige Zeile angeben.
Das ist die Kunst vom Entfernen von Fehlern, auch Debuggen genannt. (Bug = Fehler)

Nun haben wir jedenfalls das Grundgerüst für unser Programm und können jetzt so richtig auf die Kake hauen.



2. Variablen

Jeder von euch, der schon im Mathematikuntericht eine Gleichung lösen musste, kennt Variablen bereits, vielleicht einfach nur unter dem Namen "Parameter" oder dem wohlbekannten "X".
Der Sinn und Zweck von Variablen ist das Speichern eines Zahlenwertes. Wie auch bei einer Gleichung steht also die Variabel für eine bestimmte Zahl, nur dass sie, anders als in einer Gleichung, beim Programmieren veränderbar ist.
Bevor wir aber in unserem Script eine Variable gebrauchen können, müssen wir sie zuerst definieren. Dazu brauchen wir den Befehl "var", die Abkürzung für Variabel. Ein Definition in Lite-C ist immer etwa gleich aufgebaut:
Zuerst sagen wir der Engine, was es ist, danach wie es heisst, und am Schluss, was es enthält. Eine Variabel wird also so definiert:



Dieser Befehl definiert eine Variabel mit dem Namen a, welche den Zahlenwert 0 enthält.
wir könnten die Variable auch "hans" oder "fritz" nennen, aber der Name Variabel sollte möglichst kurz gehalten werden, da wir ihn oft schreiben werden.
Wie bei allen Befehlen kann man hier die Formatierung verändern, wie man will. Absätze sowie Leerzeichen zwischen den einzelnen Wörtern sind dem Compiler egal/er ignoriert sie.
Diese Kombination ginge genauso:

var a = 0 ;

oder:

var
a
=
0
;

Das gilt für jeden Befehl.
Wie ihr es macht ist euch überlassen, Hauptsache, für euch ist es Übersichtlich.
Definitionen können wir ausserhalb sowie innerhalb einer Funktion schreiben. Was dabei genau der Unterschied ist, besprechen wir später.
Wir wollen diese Variabel nun jedenfalls ausserhalb einer Funktion definieren und schreiben die Definition an den Anfang unseres Scripts unter die beiden includes.
Unser ganzer Script sollte nun so aussehen:




Jetzt, wo wir a definiert haben, können wir auch damit arbeiten.
Dies müssen wir nun wieder in einer Funktion drin machen, das es sich ja um keine Definition mehr handelt.
Fangen wir mal klein an und setzen wir die Variabel auf 6.
Dazu schreiben wir einfach "a=6;" in die Main-Funktion. (Semikolon nicht vergessen!)
Nun, wenn wir jetzt unseren Script starten würden, würden wir nur einen schwarzen Bildschirm sehen.
desshalb schreiben wir noch folgende Definition in unseren Script:



Diesen Code besprechen wir erst in Lektion 5, im Moment müsst ihr euch damit begnügen, dass er anzeigt, welcher Wert a hat.
Unser ganzer Code sieht nun so aus:



Mal schauen obs funktioniert! Speichert euren Script und drückt auf "Test run".
Siehe da, unsere Zahl ist am Bildschirm zu sehen, und sie hat richtigerweise den Wert 6.
Nun wollen wir aber ein wenig mehr mit dieser Variabel anstellen als sie einfach nur auf 6 zu setzen.
Addieren wir doch mal 5 dazu.
Nun können wir aber nicht einfach "a+5;" reinschreiben.
Der Compiler würde uns wieder eine Fehlermeldung geben.
Mit "a+5;" sagen wir dem Compiler nämlich: "11"
Er weiss jetzt nur, woher diese Zahl kommt, nicht aber was er mit ihr machen soll, und gibt uns daher eine Fehlermeldung.
Desshalb müssen wir ihm noch sagen, wo dieser Zahlenwert hinsoll, nämlich zu a:
"a=a+5;"
Fügen wir das nun also in die Main-funktion ein, starten den Script, und siehe da, a hat den Wert 11.
Nun können wir mit a machen, was wir wollen, es mit 7 subtrahieren ("a=a-7;"), mit 6 dividieren ("a=a/6;"), mit 3 Multiplizieren ("a=a*3;"), etc. etc.
Ist das nicht ein schönes Gefühl?
Experimentiert noch ein wenig damit rum, macht eine kleine Pause, dann machen wir weiter.



3. if und else


Nun wissen wir, was Variablen sind und wie man sie verändert. Das ist ja schön und gut, aber mit der Zeit ein wenig langweilig.
Desshalb kommen wir nun zur berühmt berüchtigten if/else Verzweigung. Das ist folgendermassen aufgebaut:



Kommen wir ersteinmal zu "if". (englisch, bedeutet "falls")
Es prüft, ob das, was zwischen den runden Klammern steht, nicht 0 ist. Wenn dies zutrifft, wird der Code zwischen den geschweiften Klammern ausgeführt, ansonsten wird dieser überflogen/ignoriert.
Beispiel:



Zuerst wird a auf 3 gesetzt. Dann prüft "if", ob in den Klammern etwas anderes als 0 steht. Dies trifft hier zu, also wird der Code in den geschweiften Klammern ausgeführt. a hat also schlussendlich den Wert 6.
Würde anstatt "a=3;" stehen "a=0;", würde der Teil in den geschweiften Klammern nicht ausgeführt und a wäre immer noch 0.

Und schon wären wir bei "else". (Es muss aber nicht umbedingt ein else hinter einem if stehen) Steht nun nämlich in den runden Klammern von "if" die Zahl 0, wird der Code in den Geschweiften Klammern unter else ausgeführt.
Dieser wird hingegen ignoriert, wenn in den runden Klammern von "if" eine andere Zahl als 0 steht.
Beispiel:



Zuerst wird a auf 0 gesetzt, dann wird geprüft, ob a 0 ist oder nicht. Da a 0 ist, wird der Code hinter else ausgeführt, a ist also schlussendlich 4.
Ich hoffe, ihr habt bis jetzt alles mit if und else begriffen, ansonsten lest nochmals die letzten paar Zeilen langsam und aufmerksam durch.
Habt ihrs? Gut!

Bis jetzt können wir aber mit if und else noch nicht sonderlich viel anfangen, da wir ja nur prüfen können, ob eine Variable 0 oder etwas anders enthält.
Das wollen wir ändern! Und zwar mit Vergleichen. Wir können mit einem bestimmten Konstrukt prüfen, ob eine Aussage Wahr oder falsch ist.
Ist die Aussage wahr, gibt das Konstrukt 1 zurück (zurückgeben bedeutet, das Konstrukt entspricht einem Zahlenwert), ist es hingegen falsch, gibt es 0 zurück.
Vergleiche sind also wie dafür geschaffen, in if- und else-Verzweigungen eingebaut zu werden.
Diese sind so aufgebaut:
( Zahl1 Vergleichsoperator Zahl2 )

Die Zahl1 wird mit der Zahl2 verglichen. Vergleichsoperatoren gibt es folgende: (ihr solltet schon die Meisten davon vom Matheunterricht her kennen)

== ist gleichgross wie
< ist kleiner als
> ist grösser als
<= ist kleiner oder gleichgross wie
>= ist grösser oder gleichgross wie
!= ist nicht gleichgross wie



Hier ein paar Beispiele:

( 2 == 2 ) ist wahr und gibt 1 zurück
( 2 == 4 ) ist falsch und gibt 0 zurück
( 2 <= 2 ) ist wahr und gibt 1 zurück
( 2 <= 1 ) ist falsch und gibt 0 zurück
( 2 > 2 ) ist falsch und gibt 0 zurück
( 2 != 2 ) ist falsch und gibt 0 zurück
( 2 != 4 ) ist wahr und gibt 1 zurück

Das kann man jetzt wunderbar in eine Gleichung einsetzen:



(a > 3) ist hier wahr, es gibt 1 zurück, also wird der Code in den geschweiften Klammern unter "if" ausgeführt und a ist somit 6.



Hier ist (a > 3) unwahr, gibt also 0 zurück, so wird der Code unter "else" ausgeführt und a ist somit 8.

Nun gibt es für viele dieser Codes noch Abkürzungsmöglichkeiten. Diese müsst ihr leider beherrschen, da ihr sonst
den Code von Anderen nicht versteht. Ich mache für euch am besten eine kleine kompakte Liste dafür:








Das wärs erstmal über if und else.
Damit wir aber nachher was zum Arbeiten haben, schreiben wir folgendes in die Main-function:



Somit sieht das Ganze so aus:



Startet nun euren Script. (Ab soffort benutze ich nur noch den Ausdruck "Script starten", damit meine ich speichern und ausführen mit "Test run")
Nun sollte die Zahl 3 auf dem Bildschirm zu sehen sein. (((6+2)/4*2+2)/4*2)
Diesen Code kann man aber noch vereinfachen, und ich sag euch jetzt, wie.
Macht aber zuerst noch eine kleine Pause, esst nen Apfel, oder lasst euch ne Pizza kommen, geht mal kurz aufs Klo...



4. Funktionen


Eine Funktion kennt ihr schon, und zwar die Function-main. Funktionen müssen wie eine Variable definiert werden, nur enthalten diese nicht nur eine einzelne Zahl,
sondern einen ganzen Ablauf. Wie man eine Funktion definiert, könnt ihr von der Main-function ablesen:



Auch hier sagen wir wie bei einer Variabel der Engine zuerst, dass es sich um eine Funktion handelt, dann sagen wir ihr, welchen Namen sie hat, und dann was sie enthält.
In die runden Klammern kommt auch noch was, aber dazu später mehr. Nun fragt ihr euch bestimmt, wofür das gut ist. Schaut mal auf unseren jetzigen Code.
Wir haben in der MainFunktion 3-mal das Gleiche:





Das können wir jetzt mit Funktionen abkürzen.
Dazu schreiben wir betreffenden Code einfach in eine andere Funktion und löschen die 3 if-Anweisungen.
Nennen wir die Funktion "zahlenspiel". Jetzt sollte es bei euch etwa so aussehen:



Wenn wir das jetzt starten würden, bekämen wir für a die Zahl 6, denn die Funktion die wir geschrieben haben wird nicht ausgeführt. Wir haben der Engine ja auch noch gar nicht gesagt, dass sie das tun soll.
Dies tun wir jetzt, indem wir folgendes in die Main-function schreiben:


(Semikolon nicht vergessen)

Wir schreiben dies dreimal, denn die Funktion sollte auch dreimal ausgeführt werden.
Die Drei Funktionen werden jetzt aber nicht gleichzeitig ausgeführt, die Mainfunktion wird so lange pausiert, bis die Funktion fertig ist und geht dann erst weiter.
Aber das ist auch genau das, was wir wollen.
Startet nun euren Script, und ihr seht, a ist nun wieder 3.


5. Lokale und globale Variablen


Die Variabel a, welche wir in unserem Script definiert haben, ist eine globale Variabel, denn sie gilt für den ganzen Script.
Nun gibt es auch lokale Variabeln. Diese werden im Gegensatz zur globalen Variabel in einer Funktion definiert, und gilt somit nur in besagter Funktion.
Eine lokale Variabel hat den Vorteil, dass man die Funktion in der diese definiert wurde mehrmals ausführen kann, ohne dass diese in all diesen Funktionen den gleichen Wert hat.
Dazu ein kleines Beispiel mit 2 Funktionen:




Die Variabel a wurde ausserhalb der Funktionen definiert, ist also somit global und kann in jeder Funktion dieses Scripts verwendet werden.
Die Variabel b hingegen wurde in der Funktion "beispiel1" definiert und kann somit auch nur in dieser Funktion benutzt werden.
Würden wir hier in der Funktion "Beispiel2" die variabel b verwenden, würden wir eine Fehlermeldung bekommen.
Wichtig:
Globale Variablen müssen immer am Anfang des Scripts definiert werden. Beispiel:



Das a in der Funktion "beispiel1" würde eine Fehlermeldung verursachen. Denn der Compiler liest ja von oben nach unten, somit kennt er die Variabel a in der Funktion "beispiel1" noch gar nicht.

Ihr habt euch bestimmt gefragt, wofür die runden Klammern bei den Funktionen bedeuten. Nun, dort drin definieren wir ebenfalls lokale Variablen (und sonstiges), aber solche, welche wir schon beim Funktionsaufruf verändern können.
Das lässt sich wie immer am besten mit einem Beispiel erklären:




Bei der Definition der Funktion wird hier eine lokale Variabel namens b erstellt, welche den Wert erhält, welchen wir ihr beim Funktionsaufruf zuweisen, in diesem Fall 4.
a hätte hier also den Wert 6.

Eine einzige Variabel ist aber ein bisschen wenig. Aber natürlich kann man auch mehrere definieren, man trennt diese dann einfach mit einem Komma:



a hätte hier den Wert 15.

Nun wollen wir aber unseren eigenen Script mit dem neuen Wissen ein wenig aufpeppen.
Löscht dazu zuerst das "alte" Zeug, damit wir Platz haben für Neues. So muss euer Script aussehen:



Wie es weiter geht ist nun eure Aufgabe.




6. Hausaufgaben Lektion 2

Macht folgendes:




Abgabethermin ist Montag 16.8.2010, macht es aber besser schon früher, denn die Hausaufgaben von Lektion 3 sind ebenfalls auf diesen Thermin. (Es ging nicht anders, weil ich in dieser Zeit abwesend bin)
Viel Spass.

warum muss a den 25 sein währe es nicht sinvoller wenn a 13 ist da ja ab da nur noch b/2
gerechnet wird?

_________________

bitte levelt mein geckarbor!

Also zuerst wird ja solange 4 zu a addiert, bis es 16 ist.
b ist dann 18, weil a nach 3-maliger Addition noch 12 ist.
a = 16
b/2 = 9

16 + 9 = 25

b/2 erfolgt nur einmal, und zwar dann, wenn a grösser ist als 13.
Die Formulierung der Aufgabe ist nicht ganz so toll, aber ich habs nicht besser hingebracht... :/