Programmieren
Diese Anleitung soll als Einführung in die Software-Entwicklung dienen. Die erste Priorität spielt dabei die allgemeine Programmiertechnik (damit man ein Verständnis für das Programmieren bekommt)
Ausserdem versuche ich gleichzeitig auf ein paar grundlegende Sachen in Bezug auf die Programmiersprache C++ einzugehen.
Diese Anleitung sollte sich ursprünglich auf die Programmiersprache ANSIC beziehen. Allerdings habe ich mich dann auf Grund eines Kooperationsprojektes mit meinem Kumpel (Graphi) entschlossen, sie nach C++ hin um zu portieren.
Allgemeine Einführung
- Variablen
- Schleifen (cooming soon)
-Funktionen (cooming soon)
-others (cooming soon)
[...]
Entwurfsnotation (Beispiel)
------------------------------------------------------------------------------------------------
Programmiertechniken allgemein:
Um ein Programm entwickeln zu können, muß man sich
logischerweise erst einmal darüber Gedanken machen, wie man dies
bewerkstelligen kann.
Jeder (halbwegs vernünftige) Programmierer entwickelt erst
einmal einen abstrakten Entwurf
des Programmes (in Form einer Notation).
Danach teilt er (oder sie) das gesamte Programm (-wie in dem
folgenden Beispiel beschrieben-) in viele
"Unterprogramme" (Funktionen) auf.
Problem:
Es soll ein Programm entwickelt werden, welches Musikdateien
akkustich wiedergeben soll (wie z.B. der Windows-Mediaplayer).
Dieses Player soll zum einem Samples im .wav und .mp3 -Format als
auch normale MusikCD´s abspielen können.
Als erstes wird ein abstrakter (oberflächlicher) Entwurf
entwickelt.
Was soll das Programm können? (Welche Funktionen soll es
haben?):
-Zum einem soll es die jeweilige Musikkdatei abspielen können
(indem man auf "Play" drückt),
-ausserdem soll die Wiedergabe auch noch angehalten (b.z.w.
gestoppt) werden können,
-der Player soll auch über eine Lautstärke-regulierung
verfügen
-und einen Suchlauf beinhalten (damit man an die gewünschte
Stelle des Songs springen kann).
[...]
Jede Funktion wird als Problem angesehen (das
es zu lösen gilt).
Hinter so einer -für den Benutzer
offensichtlichen- Funktion
(die in Fachkreisen auch als Schnittstelle
bezeichnet wird)
wie es z.B. bei der Play-Funktion der Fall ist,
verstecken sich normalerweise viele kleinere Unterfunktionen...
Wenn wir jetzt mal nur davon ausgehen, daß das
Programm nur eine stink normale AudioCD abspielen soll, gehört
wesentlich mehr dazu, als nur die reine Wiedergabe.
Denn zuersteinmal muss die Quelle (also das
CD-Romlaufwerk in der sich die CD befindet)
angesprochen und überprüft werden, da es ja
durchaus sein kann,
-daß z.B. eine falsche CD eingelegt wurde
(und deshalb eine Fehlermeldung ausgegeben
werden muss, die den Benutzer darauf hinweist)
-oder daß in einem Computer mehrere
CD-Romlaufwerk vorhanden sind
(und der Benutzer entscheiden muss, welches
Laufwerk verwendet werden soll).
-oder[...]
Jedenfalls gewinnt dieser -Anfangs
Oberflächliche- Entwurf immer mehr an komplexität.
Erst nachdem der Entwurf alle wichtigen Details
beinhaltet, sollte man sich um die Problemlösung
(also die Übertragung in eine Programmiersprache)
kümmern.
------------------------------------------------------------------------------------------------
Praxis:
Simpel ausgedrückt, gibt ja diverse
"Programmier-Software", die es einem ermöglicht,
Programme zu entwickeln.
Das geschiet normalerweise in Form von
"Befehlen", die man dann in dem jeweiligen
"Programmier-Programm" eingibt.
Hinweis: Dieses Beispiel bezieht sich auf die Programmiersprache "Turbo Pascal"... ich werde die zwei (darauffolgende) Bilder demnächst noch durch zwei C++ Beispiele ersetzen. :)
Als Quelltext (engl. Source Code) wird die
gesamte "Befehl-Ansammlung" bezeichnet, die dann
letztendlich das Programm ausmacht.
Diese Befehle, werden von einem Programmier-Programm (dem Compiler) in ein Programm umgewandelt.
Das fertige Programm sieht dann letztendlich
so aus.
Es gibt ja relativ viele Programmiersprachen (b.z.w. "Programmier-Software" ), wie z.B. Assembler, C, Java, Turbo Pascal...
Man kann nicht mit Bestimmtheit sagen, welche Programmiersprache gut... und welche schlecht ist. Es kommt ebend ganz darauf an, was man programmieren will.
C++ ist eine der beliebtesten Programmiersprachen. Als C- Compiler (für Windows) würde ich Dir Dev-C++ empfehlen, welchen Du Dir von http://www.bloodshed.net/download.html herunterladen kannst.
Ich bin der Meinung, daß man am besten lernen kann, wenn man sich die Quelltexte von bereits vorhandenen Programmen anschaut und versucht, diese zu interpretieren und daran anschließend dasselbe Programm noch einmal (selbst) neu zu entwickelt. Denn wenn man -wie in vielen Programmierbüchern gefordert- nur alles abtipt, vergisst man das Gelernte schnell wieder. Deshalb werde ich auch ein paar Programmbeispiele (die ich extra für diese Lektion entworfen habe) auf-führen und sie (so gut ich kann) erläutern und darauf-aufbauend Aufgaben stellen, die von Dir gelöst werden müssen, damit Du dann später auch selbständig Programme schreiben kannst (um z.B. Probleme zu lösen).
Im Gegensatz zu manch anderer Programmiersprache (wie z.B. Turbo Pascal...) muß man bei C "blöderweise" auf die Groß und Kleinschreibung achten: z.B: wird Shadow Max von der Programmiersprache ANSI C als etwas anderes als shadow max oder ShADoW mAx interpretiert.
Das folgende Programm, soll auf dem Bildschirm (den Text) "ShADoW mAx" wiedergeben...
----------------------------------------------------------------------------------------------------------------
#include <iostream.h>
void main()
{
cout <<"ShADoW_mAx";
}
Nachdem der Quelltext in ein Programm umgewandelt (und dieses ausgeführt) wurde, erscheint folgendes auf dem Monitor...
-Wenn Du alles korreckt eingegeben hast, wird der Compiler es auch zu einem
Programm umwandeln... fast jede Programmiersoftware für Windows, bietet einem
die Möglich, daß geschriebene Programm sofort zu starten... wenn das nicht
möglich ist, hast DU einen Fehler wärend der Programmierung gemacht... entweder
hat Du Dich nur vertippt, oder meine Groß- Klein- Schreibeprädigt nicht so ernst
genommen und deshalb vielleicht Printf oder pRiNtF anstelle von printf geschrieben.
Wenn Du einen Fehler gemacht hat, wird Dir das der Compiler
mit-teilen, sobald dieser Deinen Source Code in ein Programm
umwandeln möchte... normalerweise erfährst Du durch die
Fehlermeldung, in welcher Zeile sich der Fehler verbirgt (und
eventuelle noch die mögliche Ursache des Fehlers) -
----------------------------------------------------------------------------------------------------------------
Jetzt werde ich den Quelltext nocheinmal
Schritt für Schritt erklären...
#include <iostream.h> | Mit dem "#include -Befehl" wird dem Computer gesagt, daß
eine Datei in das Programm mit-eingebunden wird. In diesem Fall ist es die "iostream.h"-Bibliotheksdatei, die für die Text Ein- und Ausgabe (z.B. für den "cout-Befehl") zuständig ist. Aber daß ist im Moment unwichtig! |
void main () | Mit dem "void"- Befehl, werden Programmteile eingeleitet (in diesem Beispiel ist es der Haupt-Programmteil). |
} | In den geschweiften Klammern { und } stehen
die eigendlichen Programmierbefehle, die letztendlich das
Programm ausmachen! Jedes Programmteil, beginnt mit so einer Klammer { und endet mit so einer Klammer } |
cout <<"ShADoW_mAx"; | Mit dem cout-Befehl (welcher die Englische Abkürzung
für see output ist), werden Texte... ausgegeben, die in einer zwischen
den "Anführungs-strichelchen" stehen. das "<<" verweist(den Text, auf den cout Befehl hin. |
} | Die ausleitende Klammer schließt den Programmteil |
*Befehle
Eigentlich sind das keine C-Befehle in dem Sinne,
sondern Funktionen.
Cout ist z.B: eine Funktion welche in der
Standart Input/Output (Ein/Ausgabe) Biblotheksdatei steht),
an der in diesem Beispiel das Argument
-ShADoW_mAx- übergeben wird.
Aber ich verwende lieber erst einmal den Ausdruck Befehl, weil
die genaue Bezeichnung im Moment keine Rolle spielt (und nur
verwirrend ist).
Das erste Problem, auf das Du stoßen wirst wenn Du einen längeren Text (für Dein Programm) verfasst, ist die Tatsache, daß normalerweise alles in einer Zeile ausgegeben wird...
Es nützt Dir auch überhaupt nichts, wenn Du für jede neue Zeile eine andere count-Anweisungen verwendest.
----------------------------------------------------------------------------------------------------------------
#include <iostream.h>
void main()
{
cout <<"Zeilenumbrüche...";
cout <<"Diese
Lektion wurde von ShADoW_mAx verfasst";
cout <<"Homepage
: www.shadowmax.de";
cout <<"eMail : webmaster@shadowmax.de;
cout <<"ICQ Nummer
93290776";
}
Denn so erreichst Du keinen Zeilenvorschub... das Programm, würde dann so aussehen :
----------------------------------------------------------------------------------------------------------------
Wie Du gleich sehen wirst, kannst Du Zeilen Umbrüche mit dem Format-Zeichen:
\n
erzwungen.
----------------------------------------------------------------------------------------------------------------
#include <iostream.h>
void main()
{
cout <<"Zeilenumbrüche...\n\n";
cout <<"Diese
Lektion wurde von ShADoW_mAx verfasst\n";
cout <<"Homepage
: www.shadowmax.de\n";
cout <<"eMail : webmaster@shadowmax.de\n;
cout <<"ICQ Nummer
93290776";
}
Nach jedem \n - Formatzeichen, wird der darauffolgende Text in der nächsten Zeile wiedergegeben...
----------------------------------------------------------------------------------------------------------------
Du kannst diese Formatzeichen überall zwischen den Text ...(der in Anführungs-strichelchen steht) einfügen.
Du kannst auch eine "leere" cout-Anweisung verwenden...
z.B.
cout ("\n");
Schön... jetzt weißt Du, wie
man (vordefinierten) Text, auf dem Monitor zaubern kann und damit
kannst Du sicherlich nicht mal Deine Oma beeindrucken.
Variablen
Mein Informatiklehrer sagte mir, daß man sich Variablen wie Kartons vorstellen müsse, indenen man Sachen ablegen kann, um diese dann zu einem späteren Zeitpunkt zu verwenden...
Es gibt verschiedene Typen von Variablen, z.B. Textvariablen, Zahlenvariablen...
In einer Variablen werden Werte gespeichert, die das Programm dann abrufen kann. Variablen haben immer einen bestimmten Wert, Du kannst Dir das vielleicht besser an dem folgenden Mathematischen Beispiel verdeutlichen.
2 + x = 5
9 - x = 6
Die Variable x, hat in dem Beispiel den Wert 3 (weil 2 + 3 = 5 ist). Der Wert einer Variablen, kann sich auch im Laufe des Programmes auch ändern kann. So kann es z.B. vorkommen, daß es eine Variable Lebensenergie gibt, die (in einem Spiel für den Gesundheits-status des Spielers zuständig ist und) zu Beginn des Spieles den Wert = 100 hat, aber im Verlauf des Spieles (durch Feindeinwirkung) auf 30 sinkt und dann (durch die Inanspruchnahme eines Arzt-köfferchen) sich wieder um + 40 erhöht und somit (die Variable "Lebensenergie") einen Wert von 70 hat. [siehe Anhang: Entwurfsnotation]
Das folgende Beispiel, soll Dir das nocheinmal verdeutlichen...
----------------------------------------------------------------------------------------------------------------
#include <iostream.h>
void main()
{
int Variable1 = 100;
cout <<" Die Variable, hat einen Wert von";
cout << Variable1;
}
Auf dem Bildschirm wird dann folgendes wiedergegeben...
----------------------------------------------------------------------------------------------------------------
#include <iostream.h> | Einbindung der Biblotheks-Datei "iostream.h" |
void main () | Beginn des Main- (Haupt) Programmabschnittes |
} | Programmteil-Anfang |
int Variable1 = 100; | Mit diesem Befehl hast
Du eine Variable erschaffen. Mit int hast Du den
Variablen-Typ festgelegt... Durch Variable1 hat die Variable den Namen "Variable1" erhalten. Über diesen Namen, wird sie dann später angesprochen! Durch =100; wurde der Variable der Wert = 100 zugewiesen. Bei jeder Variablen, wird zuerst der Typ der Variable festgelegt (z.B. char, int,...) und dann der Variablen-Name, unter dem dann der Wert (der Variable) angesprochen wird. Text- Variablen werden so eingeleitet char varzeichen; Zahl- Variablen werden so eingeleitet int varzahl; ... |
cout <<" Die Variable, hat einen Wert von"; | gibt den Text: "Die Variable hat einen Wert von" aus. |
cout << Variable1; | In diesem Fall, ist cout dafür zuständig, daß der Wert der Variabeln (der über ihren Namen, Variable1 angesprochen wird ) ausgegeben wird! |
} | Programmteil-Ende |
Jetzt will ich Dir mal Text-Variablen vorstellen...
Das folgende Programm, gibt den Text "Meiner Meinung nach, ist ... das atraktivste Maedchen aus unserer Klasse" aus.
Anstelle der drei Punkte, wird die Char-Variable "Textvar" wiedergegeben.
----------------------------------------------------------------------------------------------------------------
#include <iostream.h>
void main()
{
char Textvar[10] =
"Veronika";
cout <<" Die Variable, hat einen Wert von";
cout << Textvar;
cout <<"das atracktiveste Maedchen aus unserer
Klasse!\n;
}
Das ganze sieht dann etwa so aus:
----------------------------------------------------------------------------------------------------------------
#include <iostream.h> | Einbindung der Biblotheks-Datei "iostream.h" |
void main () | Beginn des Main- (Haupt) Programmabschnittes |
{ | Programmteil-Anfang |
char Textvar[10]="Veronika"; | Durch diesen Befehl, wird eine Char -Variable
erzeugt. *[1] Char steht im Deutschen für Zeichen. In einer Char-Variable, können z.B. Buchstaben... abgelegt werden. Durch ="Veronika", erhällt sie den Wert Veronika. |
cout<<"Meiner Meinung nach, ist; | Der Text:" Meiner Meinung nach, ist:" wird ausgegeben. |
cout<<Textvar); | Über diesen COut[put]-Befehl, wird der Inhalt der Char- (Zeichen) Variable auf dem Monitor angezeigt. In diesem Fall, wird "Veronika" ausgegeben. |
cout<<"das attraktivste Maedchen..."; | Zeigt den Text: "das attraktivste Meadchen aus unserer Klasse" an. |
} | Programmteil-Ende |
*[1]Dies ist in wirklichkeit keine gewöhnlich Variable, sondern eine Feldvariable (auf die ich später noch zurückkommen werde).
Es ist natürlich Schwachsinnig, ein solches Programm zu schreiben, da jeder einen anderen Geschmack hat... und vielleicht Nadine süßer findet, als Veronika. Und deshalb variert auch der Wert der Textvariablen (der in diesem Beispiel durch "char Textvar=Veronika;" der Wert Veronika zugewiesen wurde).
Aus diesem Grund wirst Du jetzt ein Programm entwickeln, bei dem der Benutzer des Programmes, den Wert einer Variablen selber festlegen kann.
----------------------------------------------------------------------------------------------------------------
#include <iostream.h>
void main()
{
char Textvar[10] ;
cout <<" Welches Maedchen aus unserer Klasse findest Du am
schoensten?Die Variable, hat einen Wert von";
cout << Textvar;
cout <<"das atracktiveste Maedchen aus unserer
Klasse!\n;
}
Das fertige Programm, dürfte so aussehen:
----------------------------------------------------------------------------------------------------------------
#include <iostream.h> | Einbindung der Biblotheks-Datei "iostream.h" |
void main () | Beginn des Main- (Haupt) Programmabschnittes |
{ | Programmteil-Anfang |
char Textvar[10]; | Char Variable mit dem Namen "Textvar" wird erzeugt... |
cout<<"Welches Maedchen..."; | Textausgabe |
cin>>Textvar; | Durch die cin-Anweisung,
wird der eingegebene Wert des Benutzers eingelesen
und daraufhin (wird dieser Wert) dann der Char
Variable übergeben. %s |
cout<<"Deiner Meinung nach, ist also "; | Textausgabe |
cout<<Textvar; | Der Wert der Char-Variable "Textvar" wird ausgegeben. |
cout<<"das attraktiveste Maedchen der Klasse?"; | Textausgabe |
} | Programmteil-Ende |
Apropo See Output-Befehl (cout), man könnte auch die letzten drei Zeilen in einer einzigen Printf-Anweisung unterbringen.
Das könnte dann z.B. so aussehen.
cout>>"Deiner Meinung nach, ist also " >>Textvar>>" das attracktieveste Maedchen aus unserer Klasse?");
Wie Du Anhand dieses Beispieles schon erahnen kannst, kann man ein Programm auf unterschiedlichster Weise schreiben und trotzdem letztendlich zum selben Ergebnis kommen.
Der Name einer Variable, kannst Du beliebig festgelegen, aber ich empfehle Dir, daß Du Dir Sinnvolle Variablen Namen ausdenkst, wie z.B. int Lebensenergie; , oder int Zahl1; char Name1; ...
Diese Lektion bist bei weitem noch nicht fertig... ich werde
demnächst noch auf die Mathe-funktionen, Felder,
Verzweigungen... eingehen .
-----------------------------------------------------------------------------------------------------------------------------
Mathe Funktionen
In ANSI C kann man auf diese Grundrechenarten folgendermaßen
zurückgreifen:
+ | Addition | 2 + 5 |
- | Subtraktion | 7 - 3 |
x | Multiplikation | 2 * 4 |
: | Division | 9 : 3 |
Es gibt eigentlich kein Programm, daß ohne Mathematiche Operationen auskommt.#include <iostream.h>
Das folgende Programm soll als Beispiel für den einfachen Umgang mit Mathematichen Operationen dienen.
#include <iostream.h>
int Wert1;
int Wert2;
int Ergebnis;
void main ()
{
cout << "Geben sie jetzt bitte den ersten Wert ein,
mit dem gerechnet werden soll!";
cin>>Wert1;
cout << "geben Sie jetzt bitte den zweiten Wert ein,
mit dem gerechnet werden soll!";
cin<<Wert2;
cout << "Wenn man die folgenden Werte miteinander
addiert, kommt man zum folgenden Ergebnis:"
Ergebnis = Wert1 + Wert2;
cout << Ergebnis;
cout << "Wenn man den zweiten Wert vom ersten abzieht,
kommt man zum folgenden Ergebnis:"
Ergebnis = Wert1 - Wert2;
cout << Ergebnis;
cout << "Wenn man die beiden Werte miteinander
multipliziert, kommt man zu folgenden Ergebnis:"
Ergebnis = Wert1 * Wert2;
cout << Ergebnis;
cout << "Wenn man den zweiten Wert durch den ersten
teilt, kommt man zu folgenden Ergebnis:"
Ergebnis = Wert1 / Wert2;
cout << Ergebnis;
}
-----------------------------------------------------------------------------------------------------------------------------
Vergleichsoperatoren
Wie Du vielleicht noch aus der Grundschule weisst, gibt es verschiedene Vergleichsoperatoren, mit deren Hilfe man Werte vergleichen kann.
< | ist kleiner als | 7<9 |
> | ist größer als | 21>13 |
== | ist gleich mit | 17==17 |
!= | ist ungleich mit | 12!=1798 |
In der Programmiersprache werden sie z.B: wie folgt eingesetzt:
-wenn Variable Lebensenergie < als 25, gehe zu Funktion schwer Verwundet.
-wenn Variable Lebensenergie == 0, gehe zu Funktion "tod". *
Wenn Var_Eingabe != Var_Passwort, gehe zu Funktion "falsches Passwort eingegeben".
*- das einzelne "= Zeichen" wird bei der Programmiersprache C++ allerdings nicht als Vergleichsoperator, sondern als Wert-zuweisungsoperator genutzt.
(also z.B: "Variable1= 13, oder Variable2 = Variable1...)
-der Vergleichsoperator "ist gleich" wird in C++ durch zwei "ist gleich-Zeichen" (==) dargestellt.
-----------------------------------------------------------------------------------------------------------------------------
Verzweigung (Schleifen)
Der Verlauf eines Programmes ist in der Regel variabel, weil er aus einer Vielzahl an Verzweigungen (und den damit verbundenen Funktionen) besteht.
#include <iostream.h>
Schleifen sind die wichtigsten Bestandteile in C++ (und in jeder anderen Programmiersprache).
7Schleifen werden genutzt, um Programme in verschiedene Bahnen zu lenken. Sie sind also da, um den Ablauf eines Programmes zu ändern.
Ein Programm besteht nicht nur aus einer simplen abfolge von Befehlen, sondern der Verlauf eines Programmes ist in der Regel variabel, weil es aus einer Vielzahl an Verzweigungen (und damit verbundenen Funktionen) besteht.
In dem noch folgenden Bespiel, kann man dies ganz gut anhand der Dialog-Funktionen sehen.
Spieler: Jefferson hat mir
gesagt, daß Du ihm noch 2000$ schuldest;
NPC : : Ich schulde niemanden Geld! Das muss eine verwechslung
sein...
Verzweigung 1 : Ok. Auf wiedersehen.
Verzweigung 2 : Höre auf mich zu verarschen und rück die Kohle
raus, aber zackig!
Wenn man die erste Verzweigung auswählt, wird die Funktion "schliesse Dialogfunktion" aufgerufen (und das virtuelle Gespräch ist somit beendet).
Bei der zweiten Verzweigung hingegen
ein Programm ist in der Regel variabel Vielleicht wird Dir jetzt klar, warum ich vorhin ein solch schwachmathiches Beispiel (in Bezug auf das Aussehen der TopModells) gewählt habe.
-----------------------------------------------------------------------------------------------------------------------------
Der folgende Text soll eine Entwurfsnotation für ein
Computerspiel (in ihrem ersten Stadium) darstellen, welches ich
und mein Kumpel Tobi [alias BlAdE] voraussichtlich in der
nächsten Zeit (mit dem Ziel, alles für Anfänger - von Anfang
an zu erklären) entwickeln werden.
Ich habe bewusst noch keinen richtigen Bezug auf eine bestimmte
Programmiersprache genommen, da sich erst noch entscheiden muss,
in welcher Sprache das Spiel geschrieben wird.
Entwurfs-Notation (Version 1.03)
Genre: Strategie Spiel (Vogelperspektive)
Story: entweder Söldner (like Jagged Alliance) oder
Gangster/Spezialeinsatzkommando
Ziel des Spieles ist es, bestimmte Aufträge zu erfüllen (und
gegebenfalls noch nicht lineare Quest´s zu lösen).
Die Auswahl der Aufträge, hängt von dem Schwierigkeitsgrad des
jeweiligen Spieles ab. (Vorschlag: Für den Schwierigkeitsgrad
könnte man Variable verwenden, die z.B. die Durchschlagskraft
oder die Reichweite der gegnerischen Waffe um einen gewissen
Faktor erhöht b.z.w. die des Spielers mindert)
mögliche Auftragsarten:
-Suchen und zerstören
-Beschaffung eines (oder mehrerer) Gegenstände
-Gefangennahme einer (oder mehrerer) Personen
-Befreiung einer (oder mehrerer) Personen
-Eskortierung einer (oder mehrerer) Personen
-Spezialaufträge (z.B. Bombenlegung)
Die verfügbaren Aufträge stehen auf einer Art Black Board.
Oder werden bei einem Rollenspiel in Form von Quest angeboten.
Bei einem reinem Actionspiel,
müssen (um die Aufträge erfüllen zu können) Söldner
angeheuert werden
(und gegebenfalls Ausrüstungsgegenstände und Waffen gekauft
werden).
Die Söldner bekommen unterschiedliche Löhne und besitzen
verschiedene Eigenschaften.
Eigenschaften:
-Gesundheit
-Kondition
-Treffsicherheit
-Sprengstoff
Gesundheitsstatus:
Der Gesundheitsstatus spiegelt die Lebensenergie des jeweiligen
Söldners wieder.
Wenn dieser Wert (z.B. durch Feindeinwirkung) unter 25% sinkt,
ist die Person
bewusstlos (Funktion gehen, schiessen [...] nicht mehr möglich).
Mit Hilfe von Arztkoffern, kann die Gesundheit des Söldners
wiederhergestellt werden.
Aktionen:
-bewegen (laufen/rennen, kriechen [...])
-kämpfen (schiessen, boxen [...])
-Spezialaktionen (Bomben legen/entschärfen, Gegenstände
aufnehmen/ablegen [...];
------------------------------------------------------------------------------------
Beispiele für mögliche Waffen:
Handfeuerwaffen:
Schussanzahl Durchschlagskraft Reichweite Schussfrequenz
Nachladerate
-Beretta92F 15 20-25 20 1.90/sek 4 Sekunden;
-45.Revolver 6 22-30 20 1.50/sek 8 Sekunden;
-Desert Eagel 9 28-35 30 1.70/sek 4 Sekunden;
Gewehre:
Schussanzahl Durchschlagskraft Reichweite Schussfrequenz
Nachladerate
Schrotflinte 7 23-45 12 0.75/sek 9 Sekunden;
*doppel.Flinte 2 28-55 10 1.00/sek 6 Sekunden;
S-.schützengewehr 10 55-60 75 0.51/sek 10 Sekunden;
Maschienenpistolen:
Schussanzahl Durchschlagskraft Reichweite Schussfrequenz
Nachladerate
-kein Plan (mir fällt schon noch irgendwas ein :)-
Maschienengewehre:
Schussanzahl Durchschlagskraft Reichweite Schussfrequenz
Nachladerate
*M16 30 38-45 40 4.34/sek 5 Sekunden;
*Ak47 30 34-40 45 4.00/sek 5 Sekunden;
*Diese Waffen können in einem speziellen Modus abgefeuert werden
(die Doppeläufige Schrotflinte, kann z.B. beide Patronen
gleichzeitig abfeuern)
Die Maschinengewehre können im Dauerfeuermodus abgefeuert werden
(Reichweite nimmt dann ab)
[...]
eventuelle Ausrüstungsgegenstände:
Sprengstoffe (mit Zeit, Bewegungs oder Fernzünder);
Medizinkoffer (kleiner/großer erste Hilfe Koffer);
Granaten (Splittergranaten, HiExplosiv Granaten);
Kevlaweste (Schutz vor Projektilen = 40 Punkte);
[...]
-----------------------------------------------------------------------------------
Kampf: (simple Vorabversion, um das Prinzip zu erklären)
Schusswechsel (mit einer Desert Eagel aus 80m Entfernung). *[1]
Ob die Kugel trifft, ist davon abhängig:
-wie hoch die Treffsicherheit des Schützen ist,
-wie weit die Entfernung zum Ziel ist,
-und von der Reichweite der Waffe.
-(und einer zufallsgenerierten Zahl)
Beispiel
Treffsicherheit des Schützen = 90% (var_Treffsicherheit)
Entfernung zum Ziel = 80m (var_entf)
Reichweite der Waffe = 30 (var_reichw)
Die Variable (var_zufallszahl) bekommt eine Zufallsgenerierte
Zahl (zwischen 25 und 100)zugewiesen
-in diesem Beispiel hat die Variable den Wert 67 erhalten- *[2]
var_treffer1= var_zufallszahl + var_Treffsicherheit;
var_treffer1= 67 + 90
(Variable "var_treffer1" hat nun den Wert 157)
var_treffer2= var_reichw - var_entf;
var_treffer2= 30 - 80
(Variable "var_treffer2" hat nun den Wert -50)
var_trefferstatus= var_treffer1 - var_treffer2;
var_trefferstatus= 157 - 50
(die Variable "var_trefferstatus" = 107)
wenn "var_trefferstatus" = >= 100, gehe zur Funktion
"getroffen".
Funktion getroffen: (simple Vorabversion, um das Prinzip
zu erklären)
Wieviel der Treffer von der Gesundheit des Getroffenen abzieht,
ist abhängig von:
der Durchschlagskraft der Waffe,
der Panzerung des Getroffenen,
der Entfernung zum Gegner.
Beispiel:
Durchschlagskraft der Waffe = 28-35 (var_durchschlagsk*)
Entfernung zum Ziel = 80m (var_entf)
Panzerung des Gegners = 40 (var_gegnerarmor)
*Die tatsächliche Durchsschlagskraft der Waffe, wird aus einer
Zufallszahl berechnet,
die zwischen 28 und 35 liegt.
(in diesem Beispiel 30)
Der Wert (von var_durchschlagsk) wird dann mit einer
zufallsgenerierten Zahl (zwischen 2 und 4)
multipliziert. *[2]
(in diesem Beispiel 4)
var_trefferstaerke= var_realdurchschlagsk x var_zufallhit
var_trefferstaerke= 30 x 4
(die Variable "trefferstaerke" erhällt den Wert 130)
var_hit_staerke= var_trefferstaerke - var_entf
var_hit_staerke= 130 - 80
(die Variable "var_hit_staerke" erhällt den Wert 50)
var_trefferabzug= var_hit_staerke - var_gegnerarmor
var_trefferabzug= 50 - 40
(die Variable "var_trefferabzug" beinhaltet den Wert,
der von der Gesundheit des getroffenen
abgezogen wird - in diesem Fall 10)
Fortsetzung folgt !
-Storyboard Version 1.0-
(falls es ein Rollenspiel werden soll)
Hinweis:
Der folgende Entwurf beinhaltet nur die reinen Dialoge (also die
Konversationen in dem Spiel, von denen das Lösen der Quest
abhängig ist).
Die Zahlen [in den eckigen Klammern] sollen Dialog Variablen
darstellen, die für den jeweiligen Dialogzweig (in Form von
Schleifen) verwendet werden.
Eigenschaften des Spielers;
-Gesundheit;
-Treffsicherheit;
-Charisma;
-Weisheit;
-Staerke;
-Sprengstoffe;
Persönliche Eigenschaften:
-Karma;
-Intelligenz; //bei meiner Figur also = 0 :-) .
-Geschlecht; // 0 für Männlich und 1 für
Weiblich (für manche Quest b.z.w. Schleifen erforderlich)
-Alter; //Das Alter des Spielers (zwischen 16 und
65) kann zu Beginn des Spieles festgelegt werde (und erhöht sich
im Verlaufe des Spieles).
-Sexvariable; //Der Wert dieser Variable soll die
sexuelle Fähigkeit des Spielers wiederspiegeln (steigt durch
Erfahrung)
-Redegewandheit //damit den Spieler mehr Dialoge
zur Verfügung stellen (ist zum Teil abhäng von der Intelligenz)
-Überzeugungskraft //Fähigkeit um Personen
überzeugen (und ggf. erfolgreich lügen) zu können
andere Variablen
-Waffenstärke (gesamt)
-Waffenstärke (gewählte Waffe)
-Kampfkraft
Stadt1 (New Berlin):
Polizeirevier; Kneipe; Laden; Wohnhäuser; Spielhalle[Gangster´s
Paradies];
Polizei;
Auftrag:
-Beweise beschaffen, daß die Familie Schneider mit Drogen
Handelt;
[...]
Familie Schneider;
1.
-Schuldeneintreibung; (Lohn = Geld +100$)
(Jackson finden und ansprechen)
Naja... Du könntest schon einen Auftrag
für uns übernehmen.
Es gibt da so einen Typen namens "Nick", der mir noch
2000$ schuldet.
Ich will, daß Du das Geld für mich eintreibst.
Aber wenn Du mich linken willst, wirst Du mit den Konsequenzen
leben müssen....
(Nick hällt sich den Tag über in seinem Wohnhaus auf und ist in
der Nacht in der Kneipe);
Kneipe:
Jefferson hat mir gesagt, daß Du ihm noch
2000$ schuldest;
-Ich schulde niemanden Geld! Das muss eine
verwechslung sein...
Ok. Auf wiedersehen. (close Dialog -set Dialog_Variable101 = 1)
[1.1]Höre auf mich zu verarschen und rück die Kohle raus, aber
zackig!
[1.1]-Willst Du mir drohen?
Tut mir leid. Ich weiß auch nicht, was in letzter Zeit mit mir
los ist... (close Dialog)
Keineswegs. Ich werde Schneider einfach berichten, daß Du ihm
SEIN Geld nicht wiedergeben willst. [1.2]
Ich habe es nicht nötig meine Zeit mit Drohungen zu
verschwenden. Wenn Du das Geld nicht [1.3]
rausrücken willst, werd´ ich es mir ebend selbst holen müssen.
[1.2]-Ist ja schon gut... hier ist die
Kohle (Geld + 1000)
[1.3]wenn Kampfkraft >= 60%
Reg´Dich ab, Alter! Hier ist die Kohle.
wenn Kampfkraft <= 60%
Nagut... wie Du willst (solange
Nick´s Gesundheit >= 50 Nick greift den Spieler an)
Wenn Variable "Dialog_Variable101" = 1, gehe zu
(zweiter Dialoganlauf)
{zweiter Dialoganlauf}
-Was willst Du denn schon wieder von mir?
Ich bin gekommen, um das Geld abzuholen! [1.4]
Eigendlich gar nichts... Ick wollt nur mal "Hallo"
sagen. (close Dialog)
[1.4] -Ich hab Dir doch vorhin schon
gesagt, daß das eine Verwechslung sein muss!
Sorry... das hab ich völlig vergessen. Scheiß Allzheimer!
(close Dialog)
Verarschen kann ich mich auch alleine! Rück gefälligst die
Kohle Raus... oder ich mach Dich alle![1.3]
2.
-Botenjob (Koffer mit Drogen übergeben);
Auftrag:
-Du hast bewiesen, daß man Dir trauen
kann...
-Wenn Du Dir noch ein paar Mäuse verdienen willst, kannst Du
einen Botenjob für mich erledigen.
-Ich will, daß Du zu der Simpson´s Farm gehst und für mich ein
Päkchen abholst.[2.1]
[2.1.]
Das hört sich ziemlich illegal an...
ich bin ein|e aufrechte|r Mann/Frau [Geschlechtsvariable]. Ich
solch kriminelle Aktivitäten
in keinster Weise unterstützen.[2.1.1.]
-Ich kann immer etwas Kohle gebrauchen. Wo liegt denn diese Farm?
[2.1.2]
[2.1.2]-Die Farm liegt südlich von
"New Berlin"... ich hab den genauen Standort auf Deiner
Karte
-markiert.
Nagut, dann werd ich mich jetzt mal auf´m Weg machen... [2.2.1]
Ähhhmmm... ich hab´s mir doch anders überlegt. Ich werd´ das
lieber nicht machen.[2.1.1.]
[2.1.1.]
-Wie Du willst! Hau´ bloß ab... und lass
Dich hier nie wieder blicken, sonst mach´ ich Dich -alle,
kapische?
Ok. (close Dialog -set Dialog_Variable211 = 1)
Ich bin etwas schwer von Begriff, könntest Du mir das vielleicht
nochmal sagen? [2.1.2]
[2.1.2.]
-Jetzt auch noch frech werden, wa? Dafür
mach ich Dich alle!
Nein! Verschone mich bitte... ich hab´ doch ´ne Frau/Mann
[Geschlechtsvariable] und drei Kinder.[2.1.3]
Du Hosenscheisser machst mir keine Angst! (close Dialog;
Jefferson greift Spieler an)
[2.1.3]
-Das ist mir doch scheißegal...
Aber...(close Dialog; Jefferson greift Spieler an)
Komm nur her Du Wichser, ich werd´ Dir die Kniescheiben
wegballern, die Augen ausstechen,
die Zähne ausschlagen [...] (close Dialog; Jefferson greift
Spieler an)
------------------------------------------------------------------------------------------------
Farm
Personen: Wachen; Türsteher; Jimmy (Koffer); unbekannte Frau;
Türsteher:
-Warum bist Du hier?
Ich komme im Aufrag von Jefferson Schneider. Ich soll hier ein
Päkchen abholen.[3.1.]
Ich gehöre zu den Zeugen Jehoovers... und bin gekommen, um
Frieden über euch zu bringen. [3.2.]
[wenn Geschlechtsvariable = w]
Ich bin das tabulose Modell, daß ihr angeheurt habt. [3.4.]
[3.1.]
-Ok Du kannst passieren. Geh´ am besten
mal zu Jimmy, ich glaub´ der ist Dein Mann.
[3.4]
-Roooooaaar...
-So ´ne geile Maus hatten wir hier ja schon lange nicht mehr.
-Du findest Jimmy ist hinten!
(close Dialog)
[3.2.]
-Sie zu das Du Land gewinnst... oder ich
verfüttere Dich an die Hunde.
Reg Dich mal ab, Kleiner|Süsser [Geschlechtsvariable]! Ich komme
im Auftrag von Jefferson Schneider. Ich soll hier was abholen.
Mach mich nicht an, sonst mach ich Dich alle! [3.3.]
[3.3]
-Wenn Du vorhast, diese Farm irgendwann
nochmal zu verlassen, solltest Du dies jetzt tun!
Oooohhhh... wie niedlich. Der kleine Bello scheint ja richtig
sauer zu sein...
Ich werd diese Farm erst verlassen, wenn ich meinen Auftrag
erfüllt habe. [3.3.1]
[3.3.1]
-Auftrag? Weshalb bist Du denn hier?
Ich soll für Jefferson Schneider ein Päkchen abholen.[3.3.2]
Ich soll euch alle umbringen. [3.3.3]
[3.3.2]
-Na dann sag´ daß doch gleich. Am besten
Du redest mal mit Jimmy... der ist sicherlich wieder -hinten -im
Arbeitszimmer. Aber ich warne Dich, wenn Du irgendwas linkes
versuchst, wirst Du
-den morgigen Tag nicht mehr erleben.
Ok. Lass mich endlich durch! (close dialog)
Hör´ endlich auf mich zu nerven, und lass mich durch! (close
dialog)
[3.3.3.]
-Wer schickt Dich? (für alle
Schleifen dieser Verzweigung: close Dialog... Türsteher greift
Spieler an)
Walker, der Texas Ranger.
Die Familie Michellie.
Das spielt doch keine Rolle, Du wirst so oder so sterben...
Es sind diese Stimmen in meinem Kopf...
Jimmy:
-Mein Name ist Jimmy, ich leite diesen
Schuppen hier. Was kann ich für Dich tun?
Ich soll hier ein Päkchen für Jefferson abholen.[3.6.1.]
[wenn Geschlechtsvariable = w] Du kannst mir zeigen wo Dein
Schlafzimmer ist. [3.6.2]
Du könntest hier ruhig stehenbleiben, damit ich Dich besser
erschießen kann. (Angriff->Spieler)
[3.6.1.]
-Das wird ja auch Zeit. Hier ist der Koffer. (Jimmy übergibt Dir
den Koffer)
Gut... ich werde mich dann gleich mal auf´m Weg machen.
[3.6.2.]
[Wenn Sexvariable >= 40]
Du hast es echt drauf, Süsse! Hier hast Du ´n hunderter als
kleine Belohnung.
[Wenn Sexvariable < 40]
...
3.
-gegnerischen Mafiaboss umbringen;
4.
-Polizeirevier in die Luft sprengen;
Familie Kolb;
1.
-Re-aktion (auf Schneider -3) :Familie Schneider auslöschen
------------------------------------------------------------------------------------------------
*[1]
Für den Spieler offensichtlicher Abstand ist nicht 80 Meter,
sondern nur ein Bruchteil (z.B. 8m).
Aber um die Spielbalance können wir uns ja kümmern, wenn die
Engine steht.
*[2]
Diese zufallsgenerierte Zahl wird verwendet, um die das
Kampfgeschehen noch "spannender" zu
machen, da die Werte (relativ) stark varieren können.